test 7

Model_Result_Overview.py

@@ -3,7 +3,7 @@ import streamlit as st
 import pandas as pd
 from sklearn.preprocessing import MinMaxScaler
 import pickle
-
+import Streamlit_functions as sf
 from utilities import load_authenticator
 
 from utilities_with_panel import (set_header,
@@ -104,89 +104,148 @@ if auth_status:
     is_state_initiaized = st.session_state.get('initialized',False)
     if not is_state_initiaized:
         a=1
+    
+    # st.header("")
+    st.markdown("<h5 style='font-weight: normal;'>MMM Readout for Selected Period</h5>", unsafe_allow_html=True)
+    #### Input Select Start and End Date  
+    
+    # Create two columns for start date and end date input
+    col1, col2 = st.columns(2)
+        
+    with col1:
+        start_date = st.date_input("Start Date: ")
+        
+    with col2:
+        end_date = st.date_input("End Date: ")
+    
+    # Dropdown menu options
+    options = [
+        "Month on Month",
+        "Year on Year"]
+    col1, col2 = st.columns(2)
+         # Create a dropdown menu
+    with col1:
+        selected_option = st.selectbox('Select a comparision', options)
+    with col2:
+        st.write("")
+        # Waterfall chart
+    fig = sf.waterfall(start_date,end_date,selected_option)
+    st.plotly_chart(fig,use_container_width=True)
+        
+    # Waterfall table
+    shares_df = sf.shares_df_func(start_date,end_date)
+    st.table(sf.waterfall_table_func(shares_df).style.format("{:.0%}"))
+
+    ## Channel Contribution Bar Chart
+    st.plotly_chart(sf.channel_contribution(start_date,end_date),use_container_width=True)
+    # Format first three rows in percentage format
+    # styled_df = sf.shares_table_func(shares_df)
+    # # styled_df = styled_df.round(0).astype(int)
+    # styled_df.iloc[:3] = (styled_df.iloc[:3]).astype(int)
+
+        # # Round next two rows to two decimal places
+        # styled_df.iloc[3:5] = styled_df.iloc[3:5].round(0).astype(str)
+
+        # st.table(styled_df)
+    st.dataframe(sf.shares_table_func(shares_df),use_container_width=True)
+
+    st.dataframe(sf.eff_table_func(shares_df),use_container_width=True)
+
+        ### CPP CHART
+    st.plotly_chart(sf.cpp(start_date,end_date),use_container_width=True)
+        
+        ### Base decomp CHART
+    st.plotly_chart(sf.base_decomp(),use_container_width=True)
+
+        ### Media decomp CHART
+    st.plotly_chart(sf.media_decomp(),use_container_width=True)
+
+    # fig = sf.pie1(start_date,end_date)
+    # st.plotly_chart(fig,use_container_width=True)
+    # # st.dataframe(fig)
 
-    def panel_fetch(file_selected):
-        raw_data_mmm_df = pd.read_excel(file_selected, sheet_name="RAW DATA MMM")
+    # def panel_fetch(file_selected):
+    #     raw_data_mmm_df = pd.read_excel(file_selected, sheet_name="RAW DATA MMM")
 
-        if "Panel" in raw_data_mmm_df.columns:
-            panel = list(set(raw_data_mmm_df["Panel"]))
-        else:
-            raw_data_mmm_df = None
-            panel = None
+    #     if "Panel" in raw_data_mmm_df.columns:
+    #         panel = list(set(raw_data_mmm_df["Panel"]))
+    #     else:
+    #         raw_data_mmm_df = None
+    #         panel = None
 
-        return panel
+    #     return panel
 
-    def rerun():
-        st.rerun()
+    # def rerun():
+    #     st.rerun()
 
-    metrics_selected='prospects'
+    # metrics_selected='prospects'
 
-    file_selected = (
-            f"Overview_data_test_panel@#{metrics_selected}.xlsx"
-        )
-    panel_list = panel_fetch(file_selected)
+    # file_selected = (
+    #         f"Overview_data_test_panel@#{metrics_selected}.xlsx"
+    #     )
+    # panel_list = panel_fetch(file_selected)
 
-    if "selected_markets" not in st.session_state:
-        st.session_state['selected_markets']='DMA1'
+    # if "selected_markets" not in st.session_state:
+    #     st.session_state['selected_markets']='DMA1'
 
 
-    st.header('Overview of previous spends')
+    # st.header('Overview of previous spends')
 
-    selected_market= st.selectbox(
-            "Select Markets",
-            ["Total Market"] + panel_list
-        )
+    # selected_market= st.selectbox(
+    #         "Select Markets",
+    #         ["Total Market"] + panel_list
+    #     )
 
 
 
-    initialize_data(target_col,selected_market)
-    scenario = st.session_state['scenario']
-    raw_df = st.session_state['raw_df']
+    # initialize_data(target_col,selected_market)
+    # scenario = st.session_state['scenario']
+    # raw_df = st.session_state['raw_df']
     # st.write(scenario.actual_total_spends)
     # st.write(scenario.actual_total_sales)
-    columns = st.columns((1,1,3))
-
-    with columns[0]:
-        st.metric(label='Spends', value=format_numbers(float(scenario.actual_total_spends)))
-    ###print(f"##################### {scenario.actual_total_sales} ##################")
-    with columns[1]:
-        st.metric(label=target, value=format_numbers(float(scenario.actual_total_sales),include_indicator=False))
-
-
-    actual_summary_df = create_channel_summary(scenario)
-    actual_summary_df['Channel'] = actual_summary_df['Channel'].apply(channel_name_formating) 
-
-    columns = st.columns((2,1))
-    #with columns[0]:
-    with st.expander('Channel wise overview'):
-        st.markdown(actual_summary_df.style.set_table_styles(
-        [{
-            'selector': 'th',
-            'props': [('background-color', '#FFFFF')]
-        },
-            {
-            'selector' : 'tr:nth-child(even)',
-            'props' : [('background-color', '#FFFFF')]
-            }]).to_html(), unsafe_allow_html=True)
+    # columns = st.columns((1,1,3))
+
+    # with columns[0]:
+    #     st.metric(label='Spends', value=format_numbers(float(scenario.actual_total_spends)))
+    # ###print(f"##################### {scenario.actual_total_sales} ##################")
+    # with columns[1]:
+    #     st.metric(label=target, value=format_numbers(float(scenario.actual_total_sales),include_indicator=False))
+
+
+    # actual_summary_df = create_channel_summary(scenario)
+    # actual_summary_df['Channel'] = actual_summary_df['Channel'].apply(channel_name_formating) 
+
+    # columns = st.columns((2,1))
+    # #with columns[0]:
+    # with st.expander('Channel wise overview'):
+    #     st.markdown(actual_summary_df.style.set_table_styles(
+    #     [{
+    #         'selector': 'th',
+    #         'props': [('background-color', '#FFFFF')]
+    #     },
+    #         {
+    #         'selector' : 'tr:nth-child(even)',
+    #         'props' : [('background-color', '#FFFFF')]
+    #         }]).to_html(), unsafe_allow_html=True)
             
-    st.markdown("<hr>",unsafe_allow_html=True)
-    ##############################
+    # st.markdown("<hr>",unsafe_allow_html=True)
+    # ##############################
 
-    st.plotly_chart(create_contribution_pie(scenario),use_container_width=True)
-    st.markdown("<hr>",unsafe_allow_html=True)
+    # st.plotly_chart(create_contribution_pie(scenario),use_container_width=True)
+    # st.markdown("<hr>",unsafe_allow_html=True)
 
 
-    ################################3
-    st.plotly_chart(create_contribuion_stacked_plot(scenario),use_container_width=True)
-    st.markdown("<hr>",unsafe_allow_html=True)
-    #######################################
+    # ################################3
+    # st.plotly_chart(create_contribuion_stacked_plot(scenario),use_container_width=True)
+    # st.markdown("<hr>",unsafe_allow_html=True)
+    # #######################################
 
-    selected_channel_name = st.selectbox('Channel', st.session_state['channels_list'] + ['non media'], format_func=channel_name_formating)
-    selected_channel = scenario.channels.get(selected_channel_name,None)
+    # selected_channel_name = st.selectbox('Channel', st.session_state['channels_list'] + ['non media'], format_func=channel_name_formating)
+    # selected_channel = scenario.channels.get(selected_channel_name,None)
 
-    st.plotly_chart(create_channel_spends_sales_plot(selected_channel), use_container_width=True)
+    # st.plotly_chart(create_channel_spends_sales_plot(selected_channel), use_container_width=True)
 
-    st.markdown("<hr>",unsafe_allow_html=True)
+    # st.markdown("<hr>",unsafe_allow_html=True)
 
 # elif auth_status == False:
 #     st.error('Username/Password is incorrect')
@@ -201,3 +260,56 @@ if auth_status:
 #             st.error('Username not found')
 #     except Exception as e:
 #         st.error(e)
+# st.header("")
+# st.markdown("<h5 style='font-weight: normal;'>MMM Readout for Selected Period</h5>", unsafe_allow_html=True)
+# #### Input Select Start and End Date
+    
+# # Create two columns for start date and end date input
+# col1, col2 = st.columns(2)
+    
+# with col1:
+#     start_date = st.date_input("Start Date: ")
+    
+# with col2:
+#     end_date = st.date_input("End Date: ")
+# # Dropdown menu options
+# options = [
+#     "Month on Month",
+#     "Year on Year"]
+# col1, col2 = st.columns(2)
+#      # Create a dropdown menu
+# with col1:
+#     selected_option = st.selectbox('Select a comparision', options)
+# with col2:
+#     st.write("")
+#     # Waterfall chart
+# fig = sf.waterfall(start_date,end_date,selected_option)
+# st.plotly_chart(fig)
+    
+# # Waterfall table
+# shares_df = sf.shares_df_func(start_date,end_date)
+# st.table(sf.waterfall_table_func(shares_df).style.format("{:.0%}"))
+
+# ## Channel Contribution Bar Chart
+# st.plotly_chart(sf.channel_contribution(start_date,end_date))
+# # Format first three rows in percentage format
+# # styled_df = sf.shares_table_func(shares_df)
+# # # styled_df = styled_df.round(0).astype(int)
+# # styled_df.iloc[:3] = (styled_df.iloc[:3]).astype(int)
+
+#     # # Round next two rows to two decimal places
+#     # styled_df.iloc[3:5] = styled_df.iloc[3:5].round(0).astype(str)
+
+#     # st.table(styled_df)
+# st.dataframe(sf.shares_table_func(shares_df))
+
+# st.dataframe(sf.eff_table_func(shares_df))
+
+#     ### CPP CHART
+# st.plotly_chart(sf.cpp(start_date,end_date))
+    
+#     ### Base decomp CHART
+# st.plotly_chart(sf.base_decomp())
+
+#     ### Media decomp CHART
+#     st.plotly_chart(sf.media_decomp())

Streamlit_functions.py

@@ -0,0 +1,764 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.optimize import curve_fit
+from sklearn.preprocessing import MinMaxScaler
+import warnings
+import warnings
+warnings.filterwarnings("ignore")
+import os
+import plotly.graph_objects as go
+from datetime import datetime,timedelta
+from plotly.subplots import make_subplots
+import pandas as pd
+import json
+
+
+
+# working_directory = r"C:\Users\PragyaJatav\Downloads\Deliverables\Deliverables\Response Curves 09_07_24\Response Curves Resources"
+# os.chdir(working_directory)
+
+## reading input data
+df= pd.read_csv('response_curves_input_file.csv')
+df.dropna(inplace=True)
+df['Date'] = pd.to_datetime(df['Date'])
+df.reset_index(inplace=True)
+# df
+
+spend_cols = ['tv_broadcast_spend', 
+                'tv_cable_spend', 
+                'stream_video_spend', 
+                'olv_spend', 
+                'disp_prospect_spend', 
+                'disp_retarget_spend', 
+                'social_prospect_spend', 
+                'social_retarget_spend', 
+                'search_brand_spend', 
+                'search_nonbrand_spend', 
+                'cm_spend', 
+                'audio_spend', 
+                'email_spend']
+metric_cols = ['tv_broadcast_grp', 
+                 'tv_cable_grp', 
+                 'stream_video_imp', 
+                 'olv_imp', 
+                 'disp_prospect_imp', 
+                 'disp_retarget_imp', 
+                 'social_prospect_imp', 
+                 'social_retarget_imp', 
+                 'search_brand_imp', 
+                 'search_nonbrand_imp', 
+                 'cm_spend', 
+                 'audio_imp', 
+                 'email_imp']
+channels = [
+ 'BROADCAST TV',
+ 'CABLE TV',
+ 'CONNECTED & OTT TV',
+ 'VIDEO',
+ 'DISPLAY PROSPECTING',
+ 'DISPLAY RETARGETING',
+ 'SOCIAL PROSPECTING',
+ 'SOCIAL RETARGETING',
+ 'SEARCH BRAND',
+ 'SEARCH NON-BRAND',
+ 'DIGITAL PARTNERS',
+ 'AUDIO',
+ 'EMAIL']
+contribution_cols = [
+ 'Broadcast TV_Prospects',
+ 'Cable TV_Prospects',
+ 'Connected & OTT TV_Prospects',
+ 'Video_Prospects',
+ 'Display Prospecting_Prospects',
+ 'Display Retargeting_Prospects',
+ 'Social Prospecting_Prospects',
+ 'Social Retargeting_Prospects',
+ 'Search Brand_Prospects',
+ 'Search Non-brand_Prospects',
+ 'Digital Partners_Prospects',
+ 'Audio_Prospects',
+ 'Email_Prospects']
+
+def pie1(start_date,end_date):
+    start_date = pd.to_datetime(start_date)
+    end_date = pd.to_datetime(end_date)
+    cur_data = df[(df['Date'] >= start_date) & (df['Date'] <= end_date)]
+    data = cur_data[spend_cols].sum().transpose()
+    data.index = channels
+    data.columns = ["p"]
+    # Create a pie chart with custom options
+    fig = go.Figure(data=[go.Pie(
+        labels=channels, 
+        values=data["p"],
+        hoverinfo='label+percent',
+        # textinfo='value',
+        
+    )])
+
+    # Customize the layout
+    fig.update_layout(
+        title="Distribution of Spends"
+    )
+
+    # Show the figure
+    return data
+
+def waterfall(start_date,end_date,btn_chart):
+    # if pd.isnull(start_date) == True :
+    #     start_date = datetime(2024, 1, 28)
+    # if pd.isnull(end_date) == True :
+    #     end_date = datetime(2024, 2, 24)
+    # start_date = datetime.strptime(start_date, "%Y-%m-%d")
+    # end_date = datetime.strptime(end_date, "%Y-%m-%d")
+    # start_date = start_date.datetime.data
+    # end_date = end_date.datetime.data
+    start_date = pd.to_datetime(start_date)
+    end_date = pd.to_datetime(end_date)
+
+    if btn_chart == "Month on Month":
+        start_date_prev =  start_date +timedelta(weeks=-4)   
+        end_date_prev = start_date +timedelta(days=-1)   
+    else:
+        start_date_prev =  start_date +timedelta(weeks=-52)   
+        end_date_prev = start_date_prev +timedelta(weeks=4) +timedelta(days=-1) 
+        
+
+
+    prev_data = df[(df['Date'] >= start_date_prev) & (df['Date'] <= end_date_prev)]
+    cur_data = df[(df['Date'] >= start_date) & (df['Date'] <= end_date)]
+
+
+    # Example data for the waterfall chart
+    data = [
+        {'label': 'Previous Period', 'value': round(prev_data[contribution_cols].values.sum())},
+        {'label': 'Broadcast TV', 'value': round(cur_data['Broadcast TV_Prospects'].sum()-prev_data['Broadcast TV_Prospects'].sum())},
+        {'label': 'Cable TV', 'value': round(cur_data['Cable TV_Prospects'].sum()-prev_data['Cable TV_Prospects'].sum())},
+        {'label': 'Connected & OTT TV', 'value': round(cur_data['Connected & OTT TV_Prospects'].sum()-prev_data['Connected & OTT TV_Prospects'].sum())}, 
+        {'label': 'Video', 'value': round(cur_data['Video_Prospects'].sum()-prev_data['Video_Prospects'].sum())}, 
+        {'label': 'Display Prospecting', 'value': round(cur_data['Display Prospecting_Prospects'].sum()-prev_data['Display Prospecting_Prospects'].sum())},
+        {'label': 'Display Retargeting', 'value': round(cur_data['Display Retargeting_Prospects'].sum()-prev_data['Display Retargeting_Prospects'].sum())},
+        {'label': 'Social Prospecting', 'value': round(cur_data['Social Prospecting_Prospects'].sum()-prev_data['Social Prospecting_Prospects'].sum())},
+        {'label': 'Social Retargeting', 'value': round(cur_data['Social Retargeting_Prospects'].sum()-prev_data['Social Retargeting_Prospects'].sum())},
+        {'label': 'Search Brand', 'value': round(cur_data['Search Brand_Prospects'].sum()-prev_data['Search Brand_Prospects'].sum())}, 
+        {'label': 'Search Non-brand', 'value': round(cur_data['Search Non-brand_Prospects'].sum()-prev_data['Search Non-brand_Prospects'].sum())}, 
+        {'label': 'Digital Partners', 'value': round(cur_data['Digital Partners_Prospects'].sum()-prev_data['Digital Partners_Prospects'].sum())}, 
+        {'label': 'Audio', 'value': round(cur_data['Audio_Prospects'].sum()-prev_data['Audio_Prospects'].sum())}, 
+        {'label': 'Email', 'value': round(cur_data['Email_Prospects'].sum()-prev_data['Email_Prospects'].sum())},
+        {'label': 'Current Period', 'value': round(cur_data[contribution_cols].values.sum())}
+    ]
+
+    # Calculate cumulative values for the waterfall chart
+    cumulative = [0]
+    for i in range(len(data)):
+        cumulative.append(cumulative[-1] + data[i]['value'])
+
+    # Adjusting values to start from zero for both first and last columns
+    cumulative[-1] = 0  # Set the last cumulative value to zero
+
+    # Extracting labels and values
+    labels = [item['label'] for item in data]
+    values = [item['value'] for item in data]
+
+    # Plotting the waterfall chart using go.Bar
+    bars = []
+    for i in range(len(data)):
+        color = '#4A88D9' if i == 0 or i == len(data) - 1 else '#DC5537'  # Blue for first and last, gray for others
+        hover_text = f"<b>{labels[i]}</b><br>Value: {abs(values[i])}"
+
+        bars.append(go.Bar(
+            x=[labels[i]],
+            y=[cumulative[i+1] - cumulative[i]],
+            base=[cumulative[i]],
+            text=[f"{abs(values[i])}"],
+            textposition='outside',
+            hovertemplate=hover_text,
+            marker=dict(color=color),
+            showlegend=False
+        ))
+
+    # Creating the figure
+    fig = go.Figure(data=bars)
+
+    # Updating layout for black background and gray gridlines
+    if btn_chart == "Month on Month":
+        fig.update_layout(
+            title=f"Change in MMM Estimated Prospect Contribution <br>{start_date_prev.strftime('%Y-%m-%d')} to {end_date_prev.strftime('%Y-%m-%d')} vs. {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}"
+            ,showlegend=False,
+            # plot_bgcolor='black',
+            # paper_bgcolor='black',
+            # font=dict(color='white'),  # Changing font color to white for better contrast
+            xaxis=dict(
+                showgrid=False,
+                zeroline=False,  # Hiding the x-axis zero line
+            ),
+            yaxis=dict(
+                title="Prospects",
+                showgrid=True,
+                gridcolor='gray',  # Setting y-axis gridline color to gray
+                zeroline=False,  # Hiding the y-axis zero line
+                range=[18000, max(cumulative)+1000]  # Setting the y-axis range from 19k to slightly above the maximum value
+            )
+        
+        )
+    else :
+        fig.update_layout(
+            title=f"Change in MMM Estimated Prospect Contribution <br>{start_date_prev.strftime('%Y-%m-%d')} to {end_date_prev.strftime('%Y-%m-%d')} vs. {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}"
+            ,showlegend=False,
+            # plot_bgcolor='black',
+            # paper_bgcolor='black',
+            # font=dict(color='white'),  # Changing font color to white for better contrast
+            xaxis=dict(
+                showgrid=False,
+                zeroline=False,  # Hiding the x-axis zero line
+            ),
+            yaxis=dict(
+                title="Prospects",
+                showgrid=True,
+                gridcolor='gray',  # Setting y-axis gridline color to gray
+                zeroline=False,  # Hiding the y-axis zero line
+                range=[10000, max(cumulative)+1000]  # Setting the y-axis range from 19k to slightly above the maximum value
+            )
+        
+        )
+    # print(cur_data)
+    # print(prev_data)
+    # fig.show()
+    return fig
+
+def shares_df_func(start_date,end_date):
+    # if pd.isnull(start_date) == True :
+    #     start_date = datetime(2024, 1, 28)
+    # if pd.isnull(end_date) == True :
+    #     end_date = datetime(2024, 2, 24)
+
+    start_date = pd.to_datetime(start_date)
+    end_date = pd.to_datetime(end_date)
+
+    start_date_prev =  start_date +timedelta(weeks=-4)   
+    end_date_prev = start_date +timedelta(days=-1)   
+
+    prev_data = df[(df['Date'] >= start_date_prev) & (df['Date'] <= end_date_prev)]
+    cur_data = df[(df['Date'] >= start_date) & (df['Date'] <= end_date)]
+    cur_df1 = pd.DataFrame(cur_data[spend_cols].sum()).reset_index()
+    cur_df2 = pd.DataFrame(cur_data[metric_cols].sum()).reset_index()
+    cur_df3 = pd.DataFrame(cur_data[contribution_cols].sum()).reset_index()
+
+    cur_df1.columns = ["channels","cur_total_spend"]
+    cur_df2.columns = ["channels","cur_total_support"]
+    cur_df3.columns = ["channels","cur_total_contributions"]
+    cur_df1["channels"] = channels
+    cur_df2["channels"] = channels
+    cur_df3["channels"] = channels
+
+    cur_df1["cur_spend_share"] = (cur_df1["cur_total_spend"]/cur_df1["cur_total_spend"].sum())*100
+    cur_df2["cur_support_share"] = (cur_df2["cur_total_support"]/cur_df2["cur_total_support"].sum())*100
+    cur_df3["cur_contributions_share"] = (cur_df3["cur_total_contributions"]/cur_df3["cur_total_contributions"].sum())*100
+
+    prev_df1 = pd.DataFrame(prev_data[spend_cols].sum()).reset_index()
+    prev_df2 = pd.DataFrame(prev_data[metric_cols].sum()).reset_index()
+    prev_df3 = pd.DataFrame(prev_data[contribution_cols].sum()).reset_index()
+
+    prev_df1.columns = ["channels","prev_total_spend"]
+    prev_df2.columns = ["channels","prev_total_support"]
+    prev_df3.columns = ["channels","prev_total_contributions"]
+
+    prev_df1["channels"] = channels
+    prev_df2["channels"] = channels
+    prev_df3["channels"] = channels
+
+    prev_df1["prev_spend_share"] =  (prev_df1["prev_total_spend"]/prev_df1["prev_total_spend"].sum())*100
+    prev_df2["prev_support_share"] = (prev_df2["prev_total_support"]/prev_df2["prev_total_support"].sum())*100
+    prev_df3["prev_contributions_share"] = (prev_df3["prev_total_contributions"]/prev_df3["prev_total_contributions"].sum())*100
+
+    cur_df = cur_df1.merge(cur_df2,on="channels",how = "inner")
+    cur_df = cur_df.merge(cur_df3,on="channels",how = "inner")
+
+    prev_df = prev_df1.merge(prev_df2,on="channels",how = "inner")
+    prev_df = prev_df.merge(prev_df3,on="channels",how = "inner")
+
+    shares_df = cur_df.merge(prev_df,on = "channels",how = "inner")
+    shares_df["Contribution Change"] = (-shares_df["prev_contributions_share"]+shares_df["cur_contributions_share"])/shares_df["prev_contributions_share"]
+    shares_df["Support Change"] = (-shares_df["prev_support_share"]+shares_df["cur_support_share"])/shares_df["prev_support_share"]
+    shares_df["Spend Change"] = (-shares_df["prev_spend_share"]+shares_df["cur_spend_share"])/shares_df["prev_spend_share"]
+    shares_df["Efficiency Index"] = shares_df["cur_contributions_share"]/shares_df["cur_spend_share"]
+    shares_df["Effectiveness Index"] = shares_df["cur_support_share"]/shares_df["cur_spend_share"]
+    return shares_df
+
+def waterfall_table_func(shares_df):
+    ### waterfall delta table
+    # if pd.isnull(start_date) == True :
+    #     start_date = datetime(2024, 1, 28)
+    # if pd.isnull(end_date) == True :
+    #     end_date = datetime(2024, 2, 24) 
+
+    waterfall_delta_df = shares_df[["channels","Contribution Change","Support Change","Spend Change"]]
+    waterfall_delta_df = waterfall_delta_df.rename(columns = {"channels":"METRIC"})
+    waterfall_delta_df.index = waterfall_delta_df["METRIC"]
+    waterfall_delta_df = waterfall_delta_df.round(2)
+    return (waterfall_delta_df[["Contribution Change","Support Change","Spend Change"]].transpose())
+
+ 
+def channel_contribution(start_date,end_date):
+
+    # if pd.isnull(start_date) == True :
+    #     start_date = datetime(2024, 1, 28)
+    # if pd.isnull(end_date) == True :
+    #     end_date = datetime(2024, 2, 24)
+ 
+    start_date = pd.to_datetime(start_date)
+    end_date = pd.to_datetime(end_date)
+
+    cur_data = df[(df['Date'] >= start_date) & (df['Date'] <= end_date)]
+
+    channel_df = pd.DataFrame(cur_data[contribution_cols].sum()).reset_index()
+    channel_df.columns = ["channels","contributions"]
+    channel_df["channels"] = channels
+
+    # Creating the bar chart
+    fig = go.Figure(data=[go.Bar(
+        x=channel_df['channels'],
+        y=round(channel_df['contributions']),
+        marker=dict(color='rgb(74, 136, 217)'),  # Blue color for all bars
+        text=round(channel_df['contributions']),
+        textposition='outside'
+    )])
+
+    # Updating layout for better visualization
+    fig.update_layout(
+        title=f"Media Contribution <br> {cur_data['Date'].min().strftime('%Y-%m-%d')} to {cur_data['Date'].max().strftime('%Y-%m-%d')}",
+        # plot_bgcolor='black',
+        # paper_bgcolor='black',
+        # font=dict(color='white'),  # Changing font color to white for better contrast
+        xaxis=dict(
+            showgrid=False,
+            gridcolor='gray',  # Setting x-axis gridline color to gray
+            zeroline=False,  # Hiding the x-axis zero line
+        ),
+        yaxis=dict(
+            title="Prospect",
+            showgrid=True,
+            gridcolor='gray',  # Setting y-axis gridline color to gray
+            zeroline=False,  # Hiding the y-axis zero line
+        )
+    )
+
+    return fig
+def shares_table_func(shares_df):
+
+    # if pd.isnull(start_date) == True :
+    #     start_date = datetime(2024, 1, 28)
+    # if pd.isnull(end_date) == True :
+    #     end_date = datetime(2024, 2, 24) 
+
+    ### Shares tables
+    shares_table_df = shares_df[["channels","cur_spend_share","cur_support_share","cur_contributions_share","Efficiency Index","Effectiveness Index"]]
+    shares_table_df = shares_table_df.rename(columns = {"channels":"METRIC",
+                                                    "cur_spend_share":"Spend Share",
+                                                        "cur_support_share":"Support Share",
+                                                        "cur_contributions_share":"Contribution Share"})
+    shares_table_df.index = shares_table_df["METRIC"]
+    for c in ["Spend Share","Support Share","Contribution Share"]:
+        shares_table_df[c] = shares_table_df[c].astype(int)
+        shares_table_df[c] = shares_table_df[c].astype(str)+'%'
+    for c in ["Efficiency Index","Effectiveness Index"]:
+        shares_table_df[c] = shares_table_df[c].round(2).astype(str)
+    shares_table_df = shares_table_df[["Spend Share","Support Share","Contribution Share","Efficiency Index","Effectiveness Index"]].transpose()
+    return (shares_table_df)
+
+def eff_table_func(shares_df):
+
+    # if pd.isnull(start_date) == True :
+    #     start_date = datetime(2024, 1, 28)
+    # if pd.isnull(end_date) == True :
+    #     end_date = datetime(2024, 2, 24)
+
+    media_df = shares_df[['channels', 'cur_total_spend',"cur_total_support", "cur_total_contributions" ,'cur_spend_share',
+       'cur_support_share', 'cur_contributions_share',  'Efficiency Index', 'Effectiveness Index']]
+    media_df = media_df.rename(columns = {"channels":"MEDIA",
+                                                    "cur_total_spend":"TOTAL SPEND",
+                                                    "cur_total_support":"TOTAL SUPPORT",
+                                                    "cur_total_contributions":"TOTAL CONTRIBUTION",
+
+                                                    "cur_spend_share":"SPEND SHARE",
+                                                        "cur_support_share":"SUPPORT SHARE",
+                                                        "cur_contributions_share":"CONTRIBUTION SHARE",
+                                                     'Efficiency Index':'EFFICIENCY INDEX', 
+                                                     'Effectiveness Index'  :'EFFECTIVENESS INDEX'  
+                                                        })
+   
+    media_df.index = media_df["MEDIA"]
+    media_df.drop(columns = ["MEDIA"],inplace = True)
+    for c in ["TOTAL SPEND","TOTAL SUPPORT","TOTAL CONTRIBUTION"]:
+        media_df[c] = media_df[c].astype(int).astype(str)
+    for c in ["SPEND SHARE","SUPPORT SHARE","CONTRIBUTION SHARE"]:
+        media_df[c] = media_df[c].astype(int)
+        media_df[c] = media_df[c].astype(str)+'%'
+    for c in ['EFFICIENCY INDEX','EFFECTIVENESS INDEX']:
+        media_df[c] = media_df[c].round(2).astype(str)
+    return (media_df)
+
+def cpp(start_date,end_date):
+    # if pd.isnull(start_date) == True :
+    #     start_date = datetime(2024, 1, 28)
+    # if pd.isnull(end_date) == True :
+    #     end_date = datetime(2024, 2, 24)
+
+
+    start_date = pd.to_datetime(start_date)
+    end_date = pd.to_datetime(end_date)
+
+    cur_data = df[(df['Date'] >= start_date) & (df['Date'] <= end_date)]
+
+
+    fig = go.Figure()
+    colors = [
+        'rgba(74, 136, 217, 0.8)',   # Blue
+        'rgba(220, 85, 55, 0.8)',    # Red
+        'rgba(67, 150, 80, 0.8)',    # Green
+        'rgba(237, 151, 35, 0.8)',   # Orange
+        'rgba(145, 68, 255, 0.8)',   # Purple
+        'rgba(128, 128, 128, 0.8)',  # Gray
+        'rgba(255, 165, 0, 0.8)',    # Amber
+        'rgba(255, 192, 203, 0.8)',  # Pink
+        'rgba(0, 191, 255, 0.8)',    # Deep Sky Blue
+        'rgba(127, 255, 0, 0.8)',    # Chartreuse
+        'rgba(255, 69, 0, 0.8)',     # Red-Orange
+        'rgba(75, 0, 130, 0.8)',     # Indigo
+        'rgba(240, 230, 140, 0.8)',   # Khaki
+        'rgba(218, 112, 214, 0.8)'
+    ]
+
+    for i in range(0,13):
+        cpp_df = cur_data[['Date',spend_cols[i],contribution_cols[i]]]
+        cpp_df[channels[i]+"_cpp"] = cpp_df[spend_cols[i]]/cpp_df[contribution_cols[i]]
+        # Add each line trace
+        fig.add_trace(go.Scatter(x=cpp_df['Date'], y=cpp_df[channels[i]+"_cpp"], mode='lines', name=channels[i]))
+
+    # Update layout for better visualization
+    fig.update_layout(
+        title=f"CPP distribution  <br>{cur_data['Date'].min().strftime('%Y-%m-%d')} to {cur_data['Date'].max().strftime('%Y-%m-%d')}"
+        ,
+        # plot_bgcolor='black',
+        # paper_bgcolor='black',
+        # font=dict(color='white'),  # Changing font color to white for better contrast
+        xaxis=dict(
+            showgrid=True,
+            gridcolor='gray',  # Setting x-axis gridline color to gray
+            zeroline=False,  # Hiding the x-axis zero line
+        ),
+        yaxis=dict(
+            title="CPP",
+            showgrid=True,
+            gridcolor='gray',  # Setting y-axis gridline color to gray
+            zeroline=False,  # Hiding the y-axis zero line
+        ),
+        hovermode='x'  # Show hover info for all lines at a single point
+    )
+    return fig
+
+def base_decomp():
+
+    # if pd.isnull(start_date) == True :
+    #     start_date = datetime(2024, 1, 28)
+    # if pd.isnull(end_date) == True :
+    #     end_date = datetime(2024, 2, 24)
+
+    base_decomp_df = df[['Date','Unemployment', 'Competition','Trend','Seasonality','Base_0']]
+    fig = go.Figure()
+
+    # Add each line trace
+    fig.add_trace(go.Scatter(x=base_decomp_df['Date'], y=base_decomp_df['Base_0'], mode='lines', name='Trend and Seasonality'))
+    fig.add_trace(go.Scatter(x=base_decomp_df['Date'], y=base_decomp_df['Unemployment'], mode='lines', name='Unemployment'))
+    fig.add_trace(go.Scatter(x=base_decomp_df['Date'], y=base_decomp_df['Competition'], mode='lines', name='Competition'))
+
+    # Update layout for better visualization
+    fig.update_layout(
+        title=f"Base decomposition"
+        # <br>{cur_data['Date'].min().strftime('%Y-%m-%d')} to {cur_data['Date'].max().strftime('%Y-%m-%d')}"
+        ,
+        # plot_bgcolor='black',
+        # paper_bgcolor='black',
+        # font=dict(color='white'),  # Changing font color to white for better contrast
+        xaxis=dict(
+            showgrid=False,
+            gridcolor='gray',  # Setting x-axis gridline color to gray
+            zeroline=True,  # Hiding the x-axis zero line
+        ),
+        yaxis=dict(
+            title="Prospect",
+            showgrid=True,
+            gridcolor='gray',  # Setting y-axis gridline color to gray
+            zeroline=False,  # Hiding the y-axis zero line
+        ),
+        hovermode='x'  # Show hover info for all lines at a single point
+    )
+
+    return fig
+
+def media_decomp():
+    # if pd.isnull(start_date) == True :
+    #     start_date = datetime(2024, 1, 28)
+    # if pd.isnull(end_date) == True :
+    #     end_date = datetime(2024, 2, 24)
+
+    df['base'] = df[ 'Base_0']+df['Unemployment']+df['Competition']
+    cols = ['Date',        
+            'base',
+    'Broadcast TV_Prospects',
+    'Cable TV_Prospects',
+    'Connected & OTT TV_Prospects',
+    'Video_Prospects',
+    'Display Prospecting_Prospects',
+    'Display Retargeting_Prospects',
+    'Social Prospecting_Prospects',
+    'Social Retargeting_Prospects',
+    'Search Brand_Prospects',
+    'Search Non-brand_Prospects',
+    'Digital Partners_Prospects',
+    'Audio_Prospects',
+    'Email_Prospects',
+        ]
+    media_decomp_df = df[cols]
+
+        # Calculating the cumulative sum for stacking
+    cumulative_df = media_decomp_df.copy()
+    # for channel in media_decomp_df.columns[1:]:
+    #     cumulative_df[channel] = cumulative_df[channel] + cumulative_df[channel].shift(1, fill_value=0)
+
+    media_cols = media_decomp_df.columns
+    for i in range(2,len(media_cols)):
+    #     print(media_cols[i])
+        cumulative_df[media_cols[i]] = cumulative_df[media_cols[i]] + cumulative_df[media_cols[i-1]]
+    # cumulative_df
+
+    # Creating the stacked area chart
+    fig = go.Figure()
+
+    colors =colors = [
+        'rgba(74, 136, 217, 0.8)',   # Blue
+        'rgba(220, 85, 55, 0.8)',    # Red
+        'rgba(67, 150, 80, 0.8)',    # Green
+        'rgba(237, 151, 35, 0.8)',   # Orange
+        'rgba(145, 68, 255, 0.8)',   # Purple
+        'rgba(128, 128, 128, 0.8)',  # Gray
+        'rgba(255, 165, 0, 0.8)',    # Amber
+        'rgba(255, 192, 203, 0.8)',  # Pink
+        'rgba(0, 191, 255, 0.8)',    # Deep Sky Blue
+        'rgba(127, 255, 0, 0.8)',    # Chartreuse
+        'rgba(255, 69, 0, 0.8)',     # Red-Orange
+        'rgba(75, 0, 130, 0.8)',     # Indigo
+        'rgba(240, 230, 140, 0.8)',   # Khaki
+        'rgba(218, 112, 214, 0.8)'
+    ]
+
+    for idx, channel in enumerate(media_decomp_df.columns[1:]):
+        fig.add_trace(go.Scatter(
+            x=media_decomp_df['Date'],
+            y=cumulative_df[channel],
+            fill='tonexty' if idx > 0 else 'tozeroy',  # Fill to the previous curve
+            mode='none',
+            name=str.split(channel,'_')[0],
+            text=media_decomp_df[channel],  # Adding text for each point
+            hoverinfo='x+y+text',
+            fillcolor=colors[idx]  # Different color for each channel
+        ))
+
+    # Updating layout for better visualization
+    fig.update_layout(
+        title=f"Media decomposition",# <br>{cur_data['Date'].min().strftime('%Y-%m-%d')} to {cur_data['Date'].max().strftime('%Y-%m-%d')}",
+        # plot_bgcolor='black',
+        # paper_bgcolor='black',
+        # font=dict(color='white'),  # Changing font color to white for better contrast
+        xaxis=dict(
+            showgrid=False,
+            gridcolor='gray',  # Setting x-axis gridline color to gray
+            zeroline=False,  # Hiding the x-axis zero line
+        ),
+        yaxis=dict(
+        title="Prospect",
+            showgrid=True,
+            gridcolor='gray',  # Setting y-axis gridline color to gray
+            zeroline=False,  # Hiding the y-axis zero line
+        )
+    )
+
+    return fig
+
+def mmm_model_quality():
+    base_df = df[['Date',"Y_hat","Y"]]
+    fig = go.Figure()
+
+    # Add each line trace
+    fig.add_trace(go.Scatter(x=base_df['Date'], y=base_df['Y_hat'], mode='lines', name='Predicted'))
+    fig.add_trace(go.Scatter(x=base_df['Date'], y=base_df['Y'], mode='lines', name='Actual (Prospect)'))
+
+
+    # Update layout for better visualization
+    fig.update_layout(
+        title=f"MMM Model Quality"
+        ,
+        # plot_bgcolor='black',
+        # paper_bgcolor='black',
+        # font=dict(color='white'),  # Changing font color to white for better contrast
+        xaxis=dict(
+            showgrid=False,
+            gridcolor='gray',  # Setting x-axis gridline color to gray
+            zeroline=False,  # Hiding the x-axis zero line
+        ),
+        yaxis=dict(
+            title="Prospects",
+            showgrid=True,
+            gridcolor='gray',  # Setting y-axis gridline color to gray
+            zeroline=False,  # Hiding the y-axis zero line
+        ),
+        hovermode='x'  # Show hover info for all lines at a single point
+    )
+
+    return(fig)
+
+def media_data():
+    # Path to your JSON file
+    json_file_path =  "all_solutions_2024-05-09.json"
+    # Read the JSON file
+    with open(json_file_path, 'r') as file:
+        json_data = json.load(file)
+
+    # Initialize a list to store the extracted data
+    extracted_data = []
+
+    # Extract half_life and coeff from media_params
+    for params_type in ["control_params","other_params","media_params"]:
+        for media, params in json_data['solution_0']['solution'][params_type].items():
+            try:
+                extracted_data.append({
+                'category': media,# str.split(params_type,'_')[0],
+                'half_life': params['half_life'],
+                'coeff': params['coeff']
+                })
+            except:
+                extracted_data.append({
+                'category':media,# str.split(params_type,'_')[0],
+                'half_life': None,
+                'coeff': params['coeff']
+                })
+
+    media_df = pd.DataFrame(extracted_data)
+    return media_df
+
+
+def elasticity(media_df):
+    fig = go.Figure()
+    # media_df = media_df[["category","coeff"]]
+    fig.add_trace(go.Bar(
+        
+        x=media_df['coeff'],
+        y=media_df['category'],
+        orientation='h',  # Setting the orientation to horizontal
+        marker_color='rgba(75, 136, 257, 1)'  # Color for the bars
+    ))
+
+    # Updating layout for better visualization
+    fig.update_layout(
+        title="Media and Baseline Elasticity",
+        xaxis=dict(
+            title="Elasticity (coefficient)",
+            showgrid=True,
+            gridcolor='gray',  # Setting x-axis gridline color to gray
+            zeroline=False,  # Hiding the x-axis zero line
+        ),
+        yaxis=dict(
+            
+            showgrid=False,
+            gridcolor='gray',  # Setting y-axis gridline color to gray
+            zeroline=False,  # Hiding the y-axis zero line
+        ),
+        # plot_bgcolor='black',
+        # paper_bgcolor='black',
+        # font=dict(color='lightgray')  # Changing font color to white for better contrast
+    )
+    return fig
+
+
+
+
+
+
+def half_life(media_df):
+    fig = go.Figure()
+    # media_df = media_df[["category","coeff"]]
+    fig.add_trace(go.Bar(
+        
+        x=media_df[media_df['half_life'].isnull()==False]['half_life'],
+        y=media_df[media_df['half_life'].isnull()==False]['category'],
+        orientation='h',  # Setting the orientation to horizontal
+        marker_color='rgba(75, 136, 257, 1)'  # Color for the bars
+    ))
+
+    # Updating layout for better visualization
+    fig.update_layout(
+        title="Media Half-life",
+        xaxis=dict(
+            title="Weeks",
+            showgrid=True,
+            gridcolor='gray',  # Setting x-axis gridline color to gray
+            zeroline=False,  # Hiding the x-axis zero line
+        ),
+        yaxis=dict(
+            
+            showgrid=False,
+            gridcolor='gray',  # Setting y-axis gridline color to gray
+            zeroline=False,  # Hiding the y-axis zero line
+        ),
+        # plot_bgcolor='black',
+        # paper_bgcolor='black',
+        # font=dict(color='lightgray')  # Changing font color to white for better contrast
+    )
+    return fig
+
+
+# media metrics table
+n = 104
+k = 18
+
+def calculate_aic(y, y_hat):
+    n = len(y)
+    sse = np.sum((y - y_hat) ** 2)
+    aic = n * np.log(sse / n) + 2 * k
+    return aic
+
+def calculate_bic(y, y_hat):
+    n = len(y)
+    sse = np.sum((y - y_hat) ** 2)
+    bic = n * np.log(sse / n) + k * np.log(n)
+    return bic
+def calculate_r_squared(y, y_hat):
+    ss_total = np.sum((y - np.mean(y)) ** 2)
+    ss_residual = np.sum((y - y_hat) ** 2)
+    r_squared = 1 - (ss_residual / ss_total)
+    return r_squared
+
+# Function to calculate Adjusted R-squared
+def calculate_adjusted_r_squared(y, y_hat):
+    n = len(y)
+    r_squared = calculate_r_squared(y, y_hat)
+    adjusted_r_squared = 1 - ((1 - r_squared) * (n - 1) / (n - k - 1))
+    return adjusted_r_squared
+
+# Function to calculate MAPE
+def calculate_mape(y, y_hat):
+    mape = np.mean(np.abs((y - y_hat) / y)) * 100
+    return mape
+
+def model_metrics_table_func():
+    model_metrics_df = pd.DataFrame([calculate_r_squared(df["Y"], df["Y_hat"]),
+                                 calculate_adjusted_r_squared(df["Y"], df["Y_hat"]),
+                                 calculate_mape(df["Y"], df["Y_hat"]),
+                                 calculate_aic(df["Y"], df["Y_hat"]),
+                                 calculate_bic(df["Y"], df["Y_hat"])])
+    model_metrics_df.index = ["R-squared","Adjusted R-squared","MAPE","AIC","BIC"]
+    model_metrics_df = model_metrics_df.transpose()
+    model_metrics_df.index = ['']
+    return model_metrics_df.round(2)
+
+

Test/scenario_test_df.csv

@@ -2,104 +2,104 @@ other_contributions,correction,sales
 1,-890.9083269913208,5690.218095071322
 1,-475.04172715926325,5552.575607149263
 1,-3.0084997762223793,5560.943568626222
-1,-55.835992656835515,5425.282497616836
+1,-55.835992656834605,5425.282497616835
 1,-556.3423571615149,5516.629386071515
 1,-798.7293276068531,5445.739089056853
-1,-831.8661367345003,5200.4253466845
-1,-747.1985886525281,5374.302970882529
-1,-420.26596056385733,5332.913056923857
+1,-831.8661367345012,5200.425346684501
+1,-747.198588652529,5374.30297088253
+1,-420.26596056385824,5332.913056923858
 1,-271.1869770058056,5319.342549515806
-1,36.61704801202177,5391.429887731978
+1,36.61704801202086,5391.429887731979
 1,301.40268262302834,5389.612139710971
-1,-149.4327829167596,5242.93423795676
+1,-149.43278291676052,5242.934237956761
 1,-178.18371062845563,5131.547398718455
 1,-344.31242848795137,5289.838616957952
 1,-230.8534688342088,5451.796660734209
 1,123.81965248641245,5218.377356663587
 1,-346.37018641133545,5376.028569331336
-1,-271.2351337049313,5328.863885024932
+1,-271.2351337049322,5328.863885024933
 1,-354.554715570026,5403.077810960025
-1,-19.42185301387599,5485.364920013876
+1,-19.421853013877808,5485.364920013878
 1,280.9211846086464,5590.702815091353
 1,219.92735776987683,5516.867885530122
-1,781.0334815120623,5679.809801587939
-1,1294.2147923458106,5794.62514015419
+1,781.0334815120614,5679.80980158794
+1,1294.2147923458097,5794.625140154191
 1,738.501471567386,5867.577001832614
 1,796.9528952899409,5766.399026290058
-1,415.426998269626,5870.755899660374
+1,415.4269982696269,5870.755899660373
 1,786.9046031624202,5653.93211614758
-1,699.8259613792034,5780.4945612307965
+1,699.8259613792043,5780.494561230796
 1,539.745101025057,5709.584150782943
 1,377.1008301603306,5701.305955438669
 1,-171.62603119793766,5654.003287164937
 1,2.582553312521668,5483.3585810364775
-1,-34.22562033747363,5514.875846412473
+1,-34.22562033747454,5514.875846412474
 1,-232.94753657288948,5380.036090195889
-1,-468.2093499173443,5549.191483465345
-1,-322.5520717213203,5460.3946979333205
+1,-468.2093499173461,5549.191483465347
+1,-322.5520717213194,5460.39469793332
 1,-286.06881459022316,4870.059378248223
 1,-567.8495337345976,5126.330691409597
 1,-178.17958404447836,4755.834189569478
-1,-138.0179383988425,4914.4588403388425
-1,-224.74888886520512,5285.073225435204
-1,792.8627605627134,5620.162487447287
+1,-138.0179383988434,4914.458840338843
+1,-224.74888886520603,5285.073225435205
+1,792.8627605627144,5620.162487447286
 1,1355.6289643675454,6164.484521602455
-1,986.2797608661913,6162.196124983808
+1,986.2797608661922,6162.196124983807
 1,1059.455769237742,6192.769529952258
 1,383.32346060172495,6147.518456028276
 1,-187.89672830752534,5715.406060937526
-1,-212.61946644455293,5361.829613484553
+1,-212.61946644455384,5361.829613484554
 1,72.72524427662756,5103.391602309372
 1,-95.74246649852375,5238.581337104524
 1,-120.67574389038145,5559.6276727923805
-1,-129.05511796418978,5484.72889985719
-1,-225.81656994822333,5494.042520330224
-1,-218.3729272379751,5302.365695685976
+1,-129.05511796418887,5484.728899857189
+1,-225.81656994822242,5494.042520330223
+1,-218.372927237976,5302.365695685977
 1,-527.1306773658152,5229.707354409815
-1,-787.2566332929828,5426.519151763983
-1,-1039.0776762177748,5539.477859049774
+1,-787.2566332929837,5426.519151763984
+1,-1039.0776762177757,5539.477859049775
 1,-753.3501980635592,5429.758980752559
 1,-357.5844211273052,5439.306041177304
-1,-324.8985270979465,5678.245679517946
+1,-324.8985270979456,5678.245679517945
 1,-133.5001332835127,5695.581704533513
-1,-45.999364494504334,5662.909688574504
-1,-198.8982053530026,5516.533581953001
+1,-45.999364494503425,5662.909688574503
+1,-198.8982053530035,5516.533581953002
 1,-140.84226664971084,5403.844047839711
 1,-328.0694341550152,5409.443929865015
-1,-471.0469150562021,5319.741307806202
+1,-471.04691505620394,5319.741307806204
 1,-340.9581299499314,4979.624243809932
 1,-451.5102744182759,4939.252369518276
-1,-470.3738494522695,5272.673163112269
-1,-241.20911973847979,5185.85509377848
-1,208.8574132962849,5444.731311283715
+1,-470.3738494522704,5272.67316311227
+1,-241.2091197384807,5185.855093778481
+1,208.857413296284,5444.7313112837155
 1,515.8201019324006,5531.571609717599
-1,645.0637292085712,5567.486440531428
-1,600.0432433501528,5726.386967019846
+1,645.0637292085721,5567.486440531427
+1,600.0432433501519,5726.386967019847
 1,991.718208446463,5546.432488283537
 1,1013.1534153918865,5402.554699058114
 1,917.9498416432871,5331.587882096714
 1,1015.0218196550877,5173.547445494913
 1,696.1648921444839,5336.375056005516
-1,847.2335698491934,5141.959263320808
-1,306.98931138977787,5080.857405947222
-1,584.0043413540361,4984.766656686964
+1,847.2335698491943,5141.959263320807
+1,306.9893113897788,5080.857405947221
+1,584.0043413540352,4984.766656686965
 1,320.81565350241544,4936.522939377584
-1,90.34779668819192,5252.465610906807
+1,90.34779668819283,5252.465610906806
 1,403.10225090216045,5224.36913916284
-1,83.73958567298178,5191.899359654019
+1,83.73958567298087,5191.8993596540195
 1,-278.22837426408205,5013.4219235420815
-1,-594.5906903171744,5002.829538211175
+1,-594.5906903171735,5002.829538211174
 1,-638.5744723089219,4758.680377859922
 1,-820.1630688997875,5052.951763736787
 1,-777.5222929965912,5052.983144825591
-1,-937.3473140298447,5133.260108853845
-1,-766.0759176046422,5175.758653442641
+1,-937.3473140298456,5133.260108853846
+1,-766.0759176046413,5175.75865344264
 1,-601.9624005578062,5336.127374237805
 1,-43.38206579649068,5912.821508406491
-1,783.5557775286761,5872.092495641323
-1,1048.3380060975596,5779.24874920244
+1,783.555777528677,5872.092495641322
+1,1048.3380060975587,5779.248749202441
 1,942.7156660498758,5657.687045620124
 1,459.9194845831371,5422.163026676863
 1,-457.0944462735897,5375.19352051359
-1,-547.8520567101305,4949.85955425913
+1,-547.8520567101295,4949.859554259129
 1,-1007.0066006714123,5301.205921773412

all_solutions_2024-05-09.json

@@ -0,0 +1,148 @@
+{
+  "solution_0": {
+    "solution": {
+      "media_params": {
+        "Broadcast TV": {
+          "spend_col": "tv_broadcast_spend",
+          "metric_col": "tv_broadcast_grp",
+          "half_life": 1.5125527782612616,
+          "penetration": 0.7306710045225968,
+          "scale": 6661261.92832161,
+          "shape": 2.8161330383341983,
+          "coeff": 0.04000000000000001
+        },
+        "Cable TV": {
+          "spend_col": "tv_cable_spend",
+          "metric_col": "tv_cable_grp",
+          "half_life": 1.0115283431416273,
+          "penetration": 0.8645370354816814,
+          "scale": 6904015.732432723,
+          "shape": 0.38530421046089125,
+          "coeff": 0.04000000069639975
+        },
+        "Connected & OTT TV": {
+          "spend_col": "stream_video_spend",
+          "metric_col": "stream_video_imp",
+          "half_life": 0.5387407126474395,
+          "penetration": 0.37479811952034575,
+          "scale": 52395243.68927538,
+          "shape": 0.9891886048110367,
+          "coeff": 0.06999999999999999
+        },
+        "Video": {
+          "spend_col": "olv_spend",
+          "metric_col": "olv_imp",
+          "half_life": 0.9628402347042399,
+          "penetration": 0.1339338890582195,
+          "scale": 2404356.5978383864,
+          "shape": 1.7605314295228363,
+          "coeff": 0.04000000000026293
+        },
+        "Display Prospecting": {
+          "spend_col": "disp_prospect_spend",
+          "metric_col": "disp_prospect_imp",
+          "half_life": 0.3185770016152706,
+          "penetration": 0.1470527101992185,
+          "scale": 65218855.319753565,
+          "shape": 2.2826537278140124,
+          "coeff": 0.9999999999999999
+        },
+        "Display Retargeting": {
+          "spend_col": "disp_retarget_spend",
+          "metric_col": "disp_retarget_imp",
+          "half_life": 0.19649840139877658,
+          "penetration": 0.2136738043476821,
+          "scale": 52456194.86356406,
+          "shape": 1.1049988693888833,
+          "coeff": 0.9999999999999999
+        },
+        "Social Prospecting": {
+          "spend_col": "social_prospect_spend",
+          "metric_col": "social_prospect_imp",
+          "half_life": 0.23348992868088775,
+          "penetration": 0.23170623958443773,
+          "scale": 18416.13907661135,
+          "shape": 2.7416996439407058,
+          "coeff": 0.04000000000027258
+        },
+        "Social Retargeting": {
+          "spend_col": "social_retarget_spend",
+          "metric_col": "social_retarget_imp",
+          "half_life": 0.311145083025538,
+          "penetration": 0.07864050141293169,
+          "scale": 5734521.583224347,
+          "shape": 2.12760192364264,
+          "coeff": 0.09999999999999999
+        },
+        "Search Brand": {
+          "spend_col": "search_brand_spend",
+          "metric_col": "search_brand_imp",
+          "half_life": 0.6410768184353358,
+          "penetration": 0.9478746429718543,
+          "scale": 64091.710880368904,
+          "shape": 1.8822844845279567,
+          "coeff": 0.008000000000010674
+        },
+        "Search Non-brand": {
+          "spend_col": "search_nonbrand_spend",
+          "metric_col": "search_nonbrand_imp",
+          "half_life": 0.021077826067475037,
+          "penetration": 0.9970358969389862,
+          "scale": 20075934.15955288,
+          "shape": 1.0095598649180348,
+          "coeff": 0.17500000000000002
+        },
+        "Digital Partners": {
+          "spend_col": "cm_spend",
+          "metric_col": "cm_spend",
+          "half_life": 0.035288031130940034,
+          "penetration": 0.7900892706847193,
+          "scale": 16774246.211700687,
+          "shape": 0.7709184982171291,
+          "coeff": 0.5199999999999999
+        },
+        "Audio": {
+          "spend_col": "audio_spend",
+          "metric_col": "audio_imp",
+          "half_life": 0.2825119018286497,
+          "penetration": 0.5297375597273687,
+          "scale": 2068888.3017906512,
+          "shape": 1.801467700171006,
+          "coeff": 0.018000000000031005
+        },
+        "Email": {
+          "spend_col": "email_spend",
+          "metric_col": "email_imp",
+          "half_life": 0.27709327146939394,
+          "penetration": 0.3730988846104394,
+          "scale": 4565323.224523856,
+          "shape": 0.4019891584296605,
+          "coeff": 0.015000000000000001
+        }
+      },
+      "control_params": {
+        "Unemployment": {
+          "metric_col": "unemp",
+          "coeff": 1.7500000000000413
+        },
+        "Competitors spending": {
+          "metric_col": "comp_spend_log",
+          "coeff": -0.2650000008161444
+        }
+      },
+      "other_params": {
+        "Trend": {
+          "coeff": 1.0639086682507188
+        },
+        "Seasonality": {
+          "coeff": 0.9338025000581551
+        },
+        "Intercept": {
+          "coeff": -0.9999999999990916
+        }
+      }
+    },
+    "Base-Media": "Base : Media = 51% : 49%.",
+    "Best_Soln": false
+  }
+}

pages/2_Scenario_Planner.py

@@ -0,0 +1,1532 @@
+import streamlit as st
+from numerize.numerize import numerize
+import numpy as np
+from functools import partial
+from collections import OrderedDict
+from plotly.subplots import make_subplots
+import plotly.graph_objects as go
+from utilities import (
+    format_numbers,format_numbers_f,
+    load_local_css,
+    set_header,
+    initialize_data,
+    load_authenticator,
+    send_email,
+    channel_name_formating,
+)
+from classes import class_from_dict, class_to_dict
+import pickle
+import streamlit_authenticator as stauth
+import yaml
+from yaml import SafeLoader
+import re
+import pandas as pd
+import plotly.express as px
+import response_curves_model_quality as rc
+
+st.set_page_config(layout="wide")
+load_local_css("styles.css")
+set_header()
+
+
+for k, v in st.session_state.items():
+    if k not in ["logout", "login", "config"] and not k.startswith("FormSubmitter"):
+        st.session_state[k] = v
+# ======================================================== #
+# ======================= Functions ====================== #
+# ======================================================== #
+
+
+def optimize(key, status_placeholder):
+    """
+    Optimize the spends for the sales
+    """
+
+    channel_list = [
+        key for key, value in st.session_state["optimization_channels"].items() if value
+    ]
+
+    if len(channel_list) > 0:
+        scenario = st.session_state["scenario"]
+        if key.lower() == "media spends":
+            with status_placeholder:
+                with st.spinner("Optimizing"):
+                    result = st.session_state["scenario"].optimize(
+                        st.session_state["total_spends_change"], channel_list
+                    )
+        # elif key.lower() == "revenue":
+        else:
+            with status_placeholder:
+                with st.spinner("Optimizing"):
+
+                    result = st.session_state["scenario"].optimize_spends(
+                        st.session_state["total_sales_change"], channel_list
+                    )
+        for channel_name, modified_spends in result:
+
+            st.session_state[channel_name] = numerize(
+                modified_spends * scenario.channels[channel_name].conversion_rate,
+                1,
+            )
+            prev_spends = (
+                st.session_state["scenario"].channels[channel_name].actual_total_spends
+            )
+            st.session_state[f"{channel_name}_change"] = round(
+                100 * (modified_spends - prev_spends) / prev_spends, 2
+            )
+
+
+def save_scenario(scenario_name):
+    """
+    Save the current scenario with the mentioned name in the session state
+
+    Parameters
+    ----------
+    scenario_name
+        Name of the scenario to be saved
+    """
+    if "saved_scenarios" not in st.session_state:
+        st.session_state = OrderedDict()
+
+    # st.session_state['saved_scenarios'][scenario_name] = st.session_state['scenario'].save()
+    st.session_state["saved_scenarios"][scenario_name] = class_to_dict(
+        st.session_state["scenario"]
+    )
+    st.session_state["scenario_input"] = ""
+    # print(type(st.session_state['saved_scenarios']))
+    with open("../saved_scenarios.pkl", "wb") as f:
+        pickle.dump(st.session_state["saved_scenarios"], f)
+
+
+if "allow_spends_update" not in st.session_state:
+    st.session_state["allow_spends_update"] = True
+
+if "allow_sales_update" not in st.session_state:
+    st.session_state["allow_sales_update"] = True
+
+
+def update_sales_abs_slider():
+    actual_sales = _scenario.actual_total_sales
+    if validate_input(st.session_state["total_sales_change_abs_slider"]):
+        modified_sales = extract_number_for_string(
+            st.session_state["total_sales_change_abs_slider"]
+        )
+        st.session_state["total_sales_change"] = round(
+            ((modified_sales / actual_sales) - 1) * 100
+        )
+        st.session_state["total_sales_change_abs"] = numerize(modified_sales, 1)
+
+
+def update_sales_abs():
+    if (
+        st.session_state["total_sales_change_abs"]
+        in st.session_state["total_sales_change_abs_slider_options"]
+    ):
+        st.session_state["allow_sales_update"] = True
+    else:
+        st.session_state["allow_sales_update"] = False
+
+    actual_sales = _scenario.actual_total_sales
+    if (
+        validate_input(st.session_state["total_sales_change_abs"])
+        and st.session_state["allow_sales_update"]
+    ):
+        modified_sales = extract_number_for_string(
+            st.session_state["total_sales_change_abs"]
+        )
+        st.session_state["total_sales_change"] = round(
+            ((modified_sales / actual_sales) - 1) * 100
+        )
+        st.session_state["total_sales_change_abs_slider"] = numerize(modified_sales, 1)
+
+
+def update_sales():
+    st.session_state["total_sales_change_abs"] = numerize(
+        (1 + st.session_state["total_sales_change"] / 100)
+        * _scenario.actual_total_sales,
+        1,
+    )
+    st.session_state["total_sales_change_abs_slider"] = numerize(
+        (1 + st.session_state["total_sales_change"] / 100)
+        * _scenario.actual_total_sales,
+        1,
+    )
+
+
+def update_all_spends_abs_slider():
+    actual_spends = _scenario.actual_total_spends
+    if validate_input(st.session_state["total_spends_change_abs_slider"]):
+        modified_spends = extract_number_for_string(
+            st.session_state["total_spends_change_abs_slider"]
+        )
+        st.session_state["total_spends_change"] = round(
+            ((modified_spends / actual_spends) - 1) * 100
+        )
+        st.session_state["total_spends_change_abs"] = numerize(modified_spends, 1)
+
+        update_all_spends()
+
+
+# def update_all_spends_abs_slider():
+#     actual_spends = _scenario.actual_total_spends
+#     if validate_input(st.session_state["total_spends_change_abs_slider"]):
+#         print("#" * 100)
+#         print(st.session_state["total_spends_change_abs_slider"])C:\Users\PragyaJatav\Downloads\Untitled Folder 2\simulatorAldi\pages\8_Scenario_Planner.py
+#         print("#" * 100)
+
+#         modified_spends = extract_number_for_string(
+#             st.session_state["total_spends_change_abs_slider"]
+#         )
+#         st.session_state["total_spends_change"] = (
+#             (modified_spends / actual_spends) - 1
+#         ) * 100
+#         st.session_state["total_spends_change_abs"] = st.session_state[
+#             "total_spends_change_abs_slider"
+#         ]
+
+#         update_all_spends()
+
+
+def update_all_spends_abs():
+    if (
+        st.session_state["total_spends_change_abs"]
+        in st.session_state["total_spends_change_abs_slider_options"]
+    ):
+        st.session_state["allow_spends_update"] = True
+    else:
+        st.session_state["allow_spends_update"] = False
+
+    actual_spends = _scenario.actual_total_spends
+    if (
+        validate_input(st.session_state["total_spends_change_abs"])
+        and st.session_state["allow_spends_update"]
+    ):
+        modified_spends = extract_number_for_string(
+            st.session_state["total_spends_change_abs"]
+        )
+        st.session_state["total_spends_change"] = (
+            (modified_spends / actual_spends) - 1
+        ) * 100
+        st.session_state["total_spends_change_abs_slider"] = st.session_state[
+            "total_spends_change_abs"
+        ]
+
+        update_all_spends()
+
+
+def update_spends():
+    st.session_state["total_spends_change_abs"] = numerize(
+        (1 + st.session_state["total_spends_change"] / 100)
+        * _scenario.actual_total_spends,
+        1,
+    )
+    st.session_state["total_spends_change_abs_slider"] = numerize(
+        (1 + st.session_state["total_spends_change"] / 100)
+        * _scenario.actual_total_spends,
+        1,
+    )
+
+    update_all_spends()
+
+
+def update_all_spends():
+    """
+    Updates spends for all the channels with the given overall spends change
+    """
+    percent_change = st.session_state["total_spends_change"]
+
+    for channel_name in st.session_state["channels_list"]:
+        channel = st.session_state["scenario"].channels[channel_name]
+        current_spends = channel.actual_total_spends
+        modified_spends = (1 + percent_change / 100) * current_spends
+        st.session_state["scenario"].update(channel_name, modified_spends)
+        st.session_state[channel_name] = numerize(
+            modified_spends * channel.conversion_rate, 1
+        )
+        st.session_state[f"{channel_name}_change"] = percent_change
+
+
+def extract_number_for_string(string_input):
+    string_input = string_input.upper()
+    if string_input.endswith("K"):
+        return float(string_input[:-1]) * 10**3
+    elif string_input.endswith("M"):
+        return float(string_input[:-1]) * 10**6
+    elif string_input.endswith("B"):
+        return float(string_input[:-1]) * 10**9
+
+
+def validate_input(string_input):
+    pattern = r"\d+\.?\d*[K|M|B]$"
+    match = re.match(pattern, string_input)
+    if match is None:
+        return False
+    return True
+
+
+def update_data_by_percent(channel_name):
+    prev_spends = (
+        st.session_state["scenario"].channels[channel_name].actual_total_spends
+        * st.session_state["scenario"].channels[channel_name].conversion_rate
+    )
+    modified_spends = prev_spends * (
+        1 + st.session_state[f"{channel_name}_change"] / 100
+    )
+    st.session_state[channel_name] = numerize(modified_spends, 1)
+    st.session_state["scenario"].update(
+        channel_name,
+        modified_spends
+        / st.session_state["scenario"].channels[channel_name].conversion_rate,
+    )
+
+
+def update_data(channel_name):
+    """
+    Updates the spends for the given channel
+    """
+
+    if validate_input(st.session_state[channel_name]):
+        modified_spends = extract_number_for_string(st.session_state[channel_name])
+        prev_spends = (
+            st.session_state["scenario"].channels[channel_name].actual_total_spends
+            * st.session_state["scenario"].channels[channel_name].conversion_rate
+        )
+        st.session_state[f"{channel_name}_change"] = round(
+            100 * (modified_spends - prev_spends) / prev_spends, 2
+        )
+        st.session_state["scenario"].update(
+            channel_name,
+            modified_spends
+            / st.session_state["scenario"].channels[channel_name].conversion_rate,
+        )
+    # st.session_state['scenario'].update(channel_name, modified_spends)
+    # else:
+    #     try:
+    #         modified_spends = float(st.session_state[channel_name])
+    #         prev_spends = st.session_state['scenario'].channels[channel_name].actual_total_spends * st.session_state['scenario'].channels[channel_name].conversion_rate
+    #         st.session_state[f'{channel_name}_change'] = round(100*(modified_spends - prev_spends) / prev_spends,2)
+    #         st.session_state['scenario'].update(channel_name, modified_spends/st.session_state['scenario'].channels[channel_name].conversion_rate)
+    #         st.session_state[f'{channel_name}'] = numerize(modified_spends,1)
+    #     except ValueError:
+    #         st.write('Invalid input')
+
+
+def select_channel_for_optimization(channel_name):
+    """
+    Marks the given channel for optimization
+    """
+    st.session_state["optimization_channels"][channel_name] = st.session_state[
+        f"{channel_name}_selected"
+    ]
+
+
+def select_all_channels_for_optimization():
+    """
+    Marks all the channel for optimization
+    """
+    for channel_name in st.session_state["optimization_channels"].keys():
+        st.session_state[f"{channel_name}_selected"] = st.session_state[
+            "optimze_all_channels"
+        ]
+        st.session_state["optimization_channels"][channel_name] = st.session_state[
+            "optimze_all_channels"
+        ]
+
+
+def update_penalty():
+    """
+    Updates the penalty flag for sales calculation
+    """
+    st.session_state["scenario"].update_penalty(st.session_state["apply_penalty"])
+
+
+def reset_scenario(panel_selected, file_selected, updated_rcs):
+    # #print(st.session_state['default_scenario_dict'])
+    # st.session_state['scenario']  = class_from_dict(st.session_state['default_scenario_dict'])
+    # for channel in st.session_state['scenario'].channels.values():
+    #     st.session_state[channel.name] = float(channel.actual_total_spends * channel.conversion_rate)
+    # initialize_data()
+
+    if panel_selected == "Total Market":
+        initialize_data(
+            panel=panel_selected,
+            target_file=file_selected,
+            updated_rcs=updated_rcs,
+            metrics=metrics_selected,
+        )
+        panel = None
+    else:
+        initialize_data(
+            panel=panel_selected,
+            target_file=file_selected,
+            updated_rcs=updated_rcs,
+            metrics=metrics_selected,
+        )
+
+    for channel_name in st.session_state["channels_list"]:
+        st.session_state[f"{channel_name}_selected"] = False
+        st.session_state[f"{channel_name}_change"] = 0
+    st.session_state["optimze_all_channels"] = False
+
+    st.session_state["total_sales_change"] = 0
+
+    update_spends()
+    update_sales()
+
+    reset_inputs()
+
+    # st.rerun()
+
+
+def format_number(num):
+    if num >= 1_000_000:
+        return f"{num / 1_000_000:.2f}M"
+    elif num >= 1_000:
+        return f"{num / 1_000:.0f}K"
+    else:
+        return f"{num:.2f}"
+
+
+def summary_plot(data, x, y, title, text_column):
+    fig = px.bar(
+        data,
+        x=x,
+        y=y,
+        orientation="h",
+        title=title,
+        text=text_column,
+        color="Channel_name",
+    )
+
+    # Convert text_column to numeric values
+    data[text_column] = pd.to_numeric(data[text_column], errors="coerce")
+
+    # Update the format of the displayed text based on magnitude
+    fig.update_traces(
+        texttemplate="%{text:.2s}",
+        textposition="outside",
+        hovertemplate="%{x:.2s}",
+    )
+
+    fig.update_layout(xaxis_title=x, yaxis_title="Channel Name", showlegend=False)
+    return fig
+
+
+def s_curve(x, K, b, a, x0):
+    return K / (1 + b * np.exp(-a * (x - x0)))
+
+
+def find_segment_value(x, roi, mroi):
+    start_value = x[0]
+    end_value = x[len(x) - 1]
+
+    # Condition for green region: Both MROI and ROI > 1
+    green_condition = (roi > 1) & (mroi > 1)
+    left_indices = np.where(green_condition)[0]
+    left_value = x[left_indices[0]] if left_indices.size > 0 else x[0]
+
+    right_indices = np.where(green_condition)[0]
+    right_value = x[right_indices[-1]] if right_indices.size > 0 else x[0]
+
+    return start_value, end_value, left_value, right_value
+
+
+def calculate_rgba(
+    start_value, end_value, left_value, right_value, current_channel_spends
+):
+    # Initialize alpha to None for clarity
+    alpha = None
+
+    # Determine the color and calculate relative_position and alpha based on the point's position
+    if start_value <= current_channel_spends <= left_value:
+        color = "yellow"
+        relative_position = (current_channel_spends - start_value) / (
+            left_value - start_value
+        )
+        alpha = 0.8 - (0.6 * relative_position)  # Alpha decreases from start to end
+
+    elif left_value < current_channel_spends <= right_value:
+        color = "green"
+        relative_position = (current_channel_spends - left_value) / (
+            right_value - left_value
+        )
+        alpha = 0.8 - (0.6 * relative_position)  # Alpha decreases from start to end
+
+    elif right_value < current_channel_spends <= end_value:
+        color = "red"
+        relative_position = (current_channel_spends - right_value) / (
+            end_value - right_value
+        )
+        alpha = 0.2 + (0.6 * relative_position)  # Alpha increases from start to end
+
+    else:
+        # Default case, if the spends are outside the defined ranges
+        return "rgba(136, 136, 136, 0.5)"  # Grey for values outside the range
+
+    # Ensure alpha is within the intended range in case of any calculation overshoot
+    alpha = max(0.2, min(alpha, 0.8))
+
+    # Define color codes for RGBA
+    color_codes = {
+        "yellow": "255, 255, 0",  # RGB for yellow
+        "green": "0, 128, 0",  # RGB for green
+        "red": "255, 0, 0",  # RGB for red
+    }
+
+    rgba = f"rgba({color_codes[color]}, {alpha})"
+    return rgba
+
+
+def debug_temp(x_test, power, K, b, a, x0):
+    print("*" * 100)
+    # Calculate the count of bins
+    count_lower_bin = sum(1 for x in x_test if x <= 2524)
+    count_center_bin = sum(1 for x in x_test if x > 2524 and x <= 3377)
+    count_ = sum(1 for x in x_test if x > 3377)
+
+    print(
+        f"""
+            lower : {count_lower_bin}
+            center : {count_center_bin}
+            upper : {count_}
+          """
+    )
+
+
+# @st.cache
+def plot_response_curves(summary_df_sorted):
+    # rows = (
+    #     len(channels_list) // cols
+    #     if len(channels_list) % cols == 0
+    #     else len(channels_list) // cols + 1
+    # )
+    # rcs = st.session_state["rcs"]
+    # shapes = []
+    # fig = make_subplots(rows=rows, cols=cols, subplot_titles=channels_list)
+    channel_cols = [
+    'BroadcastTV',
+    'CableTV',
+    'Connected&OTTTV',
+    'DisplayProspecting',
+    'DisplayRetargeting',
+        'Video',
+    'SocialProspecting',
+    'SocialRetargeting',
+    'SearchBrand',
+    'SearchNon-brand',
+    'DigitalPartners',
+    'Audio',
+    'Email']
+    summary_df_sorted.index = summary_df_sorted["Channel_name"]
+    figures = [rc.response_curves(channels_list[i], summary_df_sorted["Optimized_spend"][channels_list[i]]/104, summary_df_sorted["New_sales"][channels_list[i]]/104) for i in range(13)]
+    
+    # Display figures in a grid layout
+    cols = st.columns(3)  # 4 columns for the grid
+
+    for idx, fig in enumerate(figures):
+        col = cols[idx % 3]
+        with col:
+            st.plotly_chart(fig, use_container_width=True)
+
+    # cols = st.columns(3)
+    # for i in range(0, len(channels_list)):
+
+    #     col = channels_list[i]
+    #     if col == "Panel":
+    #         continue
+    #     st.write(col)
+    #     x_modified = summary_df_sorted["Optimized_spend"][col]/104
+    #     y_modified = summary_df_sorted["New_sales"][col]/104
+    #     st.plotly_chart(rc.response_curves(col,x_modified,y_modified))
+        
+
+# @st.cache
+# def plot_response_curves():
+#     cols = 4
+#     rcs = st.session_state["rcs"]
+#     shapes = []
+#     fig = make_subplots(rows=6, cols=cols, subplot_titles=channels_list)
+#     for i in range(0, len(channels_list)):
+#         col = channels_list[i]
+#         x = st.session_state["actual_df"][col].values
+#         spends = x.sum()
+#         power = np.ceil(np.log(x.max()) / np.log(10)) - 3
+#         x = np.linspace(0, 3 * x.max(), 200)
+
+#         K = rcs[col]["K"]
+#         b = rcs[col]["b"]
+#         a = rcs[col]["a"]
+#         x0 = rcs[col]["x0"]
+
+#         y = s_curve(x / 10**power, K, b, a, x0)
+#         roi = y / x
+#         marginal_roi = a * (y) * (1 - y / K)
+#         fig.add_trace(
+#             go.Scatter(
+#                 x=52
+#                 * x
+#                 * st.session_state["scenario"].channels[col].conversion_rate,
+#                 y=52 * y,
+#                 name=col,
+#                 customdata=np.stack((roi, marginal_roi), axis=-1),
+#                 hovertemplate="Spend:%{x:$.2s}<br>Sale:%{y:$.2s}<br>ROI:%{customdata[0]:.3f}<br>MROI:%{customdata[1]:.3f}",
+#             ),
+#             row=1 + (i) // cols,
+#             col=i % cols + 1,
+#         )
+
+#         fig.add_trace(
+#             go.Scatter(
+#                 x=[
+#                     spends
+#                     * st.session_state["scenario"]
+#                     .channels[col]
+#                     .conversion_rate
+#                 ],
+#                 y=[52 * s_curve(spends / (10**power * 52), K, b, a, x0)],
+#                 name=col,
+#                 legendgroup=col,
+#                 showlegend=False,
+#                 marker=dict(color=["black"]),
+#             ),
+#             row=1 + (i) // cols,
+#             col=i % cols + 1,
+#         )
+
+#         shapes.append(
+#             go.layout.Shape(
+#                 type="line",
+#                 x0=0,
+#                 y0=52 * s_curve(spends / (10**power * 52), K, b, a, x0),
+#                 x1=spends
+#                 * st.session_state["scenario"].channels[col].conversion_rate,
+#                 y1=52 * s_curve(spends / (10**power * 52), K, b, a, x0),
+#                 line_width=1,
+#                 line_dash="dash",
+#                 line_color="black",
+#                 xref=f"x{i+1}",
+#                 yref=f"y{i+1}",
+#             )
+#         )
+
+#         shapes.append(
+#             go.layout.Shape(
+#                 type="line",
+#                 x0=spends
+#                 * st.session_state["scenario"].channels[col].conversion_rate,
+#                 y0=0,
+#                 x1=spends
+#                 * st.session_state["scenario"].channels[col].conversion_rate,
+#                 y1=52 * s_curve(spends / (10**power * 52), K, b, a, x0),
+#                 line_width=1,
+#                 line_dash="dash",
+#                 line_color="black",
+#                 xref=f"x{i+1}",
+#                 yref=f"y{i+1}",
+#             )
+#         )
+
+#     fig.update_layout(
+#         height=1500,
+#         width=1000,
+#         title_text="Response Curves",
+#         showlegend=False,
+#         shapes=shapes,
+#     )
+#     fig.update_annotations(font_size=10)
+#     fig.update_xaxes(title="Spends")
+#     fig.update_yaxes(title=target)
+#     return fig
+
+
+# ======================================================== #
+# ==================== HTML Components =================== #
+# ======================================================== #
+
+
+def generate_spending_header(heading):
+    return st.markdown(
+        f"""<h2 class="spends-header">{heading}</h2>""", unsafe_allow_html=True
+    )
+
+
+# ======================================================== #
+# =================== Session variables ================== #
+# ======================================================== #
+
+with open("config.yaml") as file:
+    config = yaml.load(file, Loader=SafeLoader)
+    st.session_state["config"] = config
+
+authenticator = stauth.Authenticate(
+    config["credentials"],
+    config["cookie"]["name"],
+    config["cookie"]["key"],
+    config["cookie"]["expiry_days"],
+    config["preauthorized"],
+)
+st.session_state["authenticator"] = authenticator
+name, authentication_status, username = authenticator.login("Login", "main")
+auth_status = st.session_state.get("authentication_status")
+
+import os
+import glob
+
+
+def get_excel_names(directory):
+    # Create a list to hold the final parts of the filenames
+    last_portions = []
+
+    # Patterns to match Excel files (.xlsx and .xls) that contain @#
+    patterns = [
+        os.path.join(directory, "*@#*.xlsx"),
+        os.path.join(directory, "*@#*.xls"),
+    ]
+
+    # Process each pattern
+    for pattern in patterns:
+        files = glob.glob(pattern)
+
+        # Extracting the last portion after @# for each file
+        for file in files:
+            base_name = os.path.basename(file)
+            last_portion = base_name.split("@#")[-1]
+            last_portion = last_portion.replace(".xlsx", "").replace(
+                ".xls", ""
+            )  # Removing extensions
+            last_portions.append(last_portion)
+
+    return last_portions
+
+
+def name_formating(channel_name):
+    # Replace underscores with spaces
+    name_mod = channel_name.replace("_", " ")
+
+    # Capitalize the first letter of each word
+    name_mod = name_mod.title()
+
+    return name_mod
+
+
+@st.experimental_memo(show_spinner=False)
+def panel_fetch(file_selected):
+    raw_data_mmm_df = pd.read_excel(file_selected, sheet_name="RAW DATA MMM")
+
+    # if "Panel" in raw_data_mmm_df.columns:
+    #     panel = list(set(raw_data_mmm_df["Panel"]))
+    # else:
+    #     raw_data_mmm_df = None
+    #     panel = None
+    # raw_data_mmm_df = None
+    panel = None
+    return panel
+
+
+def reset_inputs():
+    if "total_spends_change_abs" in st.session_state:
+        del st.session_state.total_spends_change_abs
+    if "total_spends_change" in st.session_state:
+        del st.session_state.total_spends_change
+    if "total_spends_change_abs_slider" in st.session_state:
+        del st.session_state.total_spends_change_abs_slider
+
+    if "total_sales_change_abs" in st.session_state:
+        del st.session_state.total_sales_change_abs
+    if "total_sales_change" in st.session_state:
+        del st.session_state.total_sales_change
+    if "total_sales_change_abs_slider" in st.session_state:
+        del st.session_state.total_sales_change_abs_slider
+
+    st.session_state["initialized"] = False
+
+
+if auth_status == True:
+    authenticator.logout("Logout", "main")
+    st.header("Scenario Planner")
+    def scenario_planner_plots():
+        
+        with st.expander('Optimized Spends Overview'):
+            # if st.button('Refresh'):
+            #     st.experimental_rerun()
+
+            import plotly.graph_objects as go
+            from plotly.subplots import make_subplots
+
+            # Define light colors for bars
+            import plotly.graph_objects as go
+            from plotly.subplots import make_subplots
+
+            st.empty()
+            #st.header('Model Result Analysis')
+            spends_data=pd.read_excel('Overview_data_test.xlsx')
+
+            with open('summary_df.pkl', 'rb') as file:
+                summary_df_sorted = pickle.load(file)
+            #st.write(summary_df_sorted)
+
+            # selected_scenario= st.selectbox('Select Saved Scenarios',['S1','S2']) 
+            summary_df_sorted=summary_df_sorted.sort_values(by=['Optimized_spend'],ascending=False)
+            summary_df_sorted['old_efficiency']=(summary_df_sorted['Old_sales']/summary_df_sorted['Old_sales'].sum())/(summary_df_sorted['Actual_spend']/summary_df_sorted['Actual_spend'].sum())
+            summary_df_sorted['new_efficiency']=(summary_df_sorted['New_sales']/summary_df_sorted['New_sales'].sum())/(summary_df_sorted['Optimized_spend']/summary_df_sorted['Optimized_spend'].sum())
+
+            summary_df_sorted['old_roi']=summary_df_sorted['Old_sales']/summary_df_sorted['Actual_spend']
+            summary_df_sorted['new_roi']=summary_df_sorted['New_sales']/summary_df_sorted['Optimized_spend']
+
+            total_actual_spend = summary_df_sorted['Actual_spend'].sum()
+            total_optimized_spend = summary_df_sorted['Optimized_spend'].sum()
+
+            actual_spend_percentage = (summary_df_sorted['Actual_spend'] / total_actual_spend) * 100
+            optimized_spend_percentage = (summary_df_sorted['Optimized_spend'] / total_optimized_spend) * 100
+
+
+
+            light_blue = 'rgba(0, 31, 120, 0.7)'
+            light_orange = 'rgba(0, 181, 219, 0.7)'
+            light_green = 'rgba(240, 61, 20, 0.7)'
+            light_red = 'rgba(250, 110, 10, 0.7)'
+            light_purple = 'rgba(255, 191, 69, 0.7)'
+
+
+            # # Create subplots with one row and two columns
+            # fig = make_subplots(rows=3, cols=1, subplot_titles=("Actual vs. Optimized Spend", "Actual vs. Optimized Contribution", "Actual vs. Optimized ROI"))
+
+            # # Add actual vs optimized spend bars
+
+            
+            # fig.add_trace(go.Bar(y=summary_df_sorted['Channel_name'], x=summary_df_sorted['Actual_spend'], name='Actual',
+            #                      text=summary_df_sorted['Actual_spend'].apply(format_number) + ' '+' (' + actual_spend_percentage.round(2).astype(str) + '%)',
+            #                        marker_color=light_blue, orientation='h'), 
+            #                      row=1,
+            #                        col=1)
+            
+            
+            # fig.add_trace(go.Bar(y=summary_df_sorted['Channel_name'], x=summary_df_sorted['Optimized_spend'], name='Optimized',
+            #                      text=summary_df_sorted['Optimized_spend'].apply(format_number) + ' (' + optimized_spend_percentage.round(2).astype(str) + '%)',
+            #                        marker_color=light_orange, 
+            #                        orientation='h'),
+            #                          row=1, 
+            #                          col=1)
+            
+            # fig.update_xaxes(title_text="Amount", row=1, col=1)
+
+            # # Add actual vs optimized Contribution
+            # fig.add_trace(go.Bar(y=summary_df_sorted['Channel_name'], x=summary_df_sorted['New_sales'],
+            #                       name='Optimized Contribution',text=summary_df_sorted['New_sales'].apply(format_number), 
+            #                       marker_color=light_orange, orientation='h',showlegend=False), row=2, col=1)
+            
+            # fig.add_trace(go.Bar(y=summary_df_sorted['Channel_name'], x=summary_df_sorted['Old_sales'], 
+            #                      name='Actual Contribution',text=summary_df_sorted['Old_sales'].apply(format_number), 
+            #                      marker_color=light_blue, orientation='h',showlegend=False), row=2, col=1)
+            
+    
+            # fig.update_xaxes(title_text="Contribution", row=2, col=1) 
+
+            # # Add actual vs optimized ROI bars
+                    
+            # fig.add_trace(go.Bar(y=summary_df_sorted['Channel_name'], x=summary_df_sorted['new_roi'], 
+            #                      name='Optimized ROI',text=summary_df_sorted['new_roi'].apply(format_number) , 
+            #                      marker_color=light_orange, orientation='h',showlegend=False), row=3, col=1)
+            
+            # fig.add_trace(go.Bar(y=summary_df_sorted['Channel_name'], x=summary_df_sorted['old_roi'], 
+            #                      name='Actual ROI', text=summary_df_sorted['old_roi'].apply(format_number) ,
+            #                        marker_color=light_blue, orientation='h',showlegend=False), row=3, col=1)
+
+            # fig.update_xaxes(title_text="ROI", row=3, col=1)
+
+            # # Update layout
+            # fig.update_layout(title_text="Actual vs. Optimized Metrics for Media Channels",
+            #                    showlegend=True, yaxis=dict(title='Media Channels', autorange="reversed"))
+
+            # st.plotly_chart(fig,use_container_width=True)
+
+            # Create subplots with one row and two columns
+            fig = go.Figure()
+            # Add actual vs optimized spend bars
+
+            
+            fig.add_trace(go.Bar(x=summary_df_sorted['Channel_name'], y=summary_df_sorted['Actual_spend'], name='Actual',
+                                text=summary_df_sorted['Actual_spend'].apply(format_number) + ' '
+                                #  + 
+                                #  ' '+
+                                # '</br> (' + actual_spend_percentage.astype(int).astype(str) + '%)'
+                                ,textposition='outside',#textfont=dict(size=30), 
+                                marker_color=light_blue))
+            
+            
+            fig.add_trace(go.Bar(x=summary_df_sorted['Channel_name'], y=summary_df_sorted['Optimized_spend'], name='Optimized',
+                                text=summary_df_sorted['Optimized_spend'].apply(format_number) + ' '
+                                #    + 
+                                #  '</br> (' + optimized_spend_percentage.astype(int).astype(str) + '%)'
+                                ,textposition='outside',#textfont=dict(size=30), 
+                                marker_color=light_orange))
+            
+            fig.update_xaxes(title_text="Channels")
+            fig.update_yaxes(title_text="Spends ($)")
+            fig.update_layout(
+                title = "Actual vs. Optimized Spends",
+                        margin=dict(t=40, b=40, l=40, r=40)
+                    )
+            
+            st.plotly_chart(fig,use_container_width=True)
+
+            # Add actual vs optimized Contribution
+            fig = go.Figure()
+            fig.add_trace(go.Bar(x=summary_df_sorted['Channel_name'], y=summary_df_sorted['Old_sales'], 
+                                name='Actual Contribution',text=summary_df_sorted['Old_sales'].apply(format_number),textposition='outside', 
+                                marker_color=light_blue,showlegend=True))
+            
+            fig.add_trace(go.Bar(x=summary_df_sorted['Channel_name'], y=summary_df_sorted['New_sales'],
+                                name='Optimized Contribution',text=summary_df_sorted['New_sales'].apply(format_number),textposition='outside', 
+                                marker_color=light_orange, showlegend=True))
+            
+            
+    
+            fig.update_yaxes(title_text="Contribution")
+            fig.update_xaxes(title_text="Channels") 
+            fig.update_layout(
+                title = "Actual vs. Optimized Contributions",
+                        margin=dict(t=40, b=40, l=40, r=40)
+                        # yaxis=dict(range=[0, 0.002]),
+                    )
+            st.plotly_chart(fig,use_container_width=True)
+
+            # Add actual vs optimized Efficiency bars
+            fig = go.Figure()
+            summary_df_sorted_p =  summary_df_sorted[summary_df_sorted['Channel_name']!="Panel"]
+            fig.add_trace(go.Bar(x=summary_df_sorted_p['Channel_name'], y=summary_df_sorted_p['old_efficiency'], 
+                                name='Actual Efficiency', text=summary_df_sorted_p['old_efficiency'].apply(format_number) ,textposition='outside',
+                                marker_color=light_blue,showlegend=True))
+            fig.add_trace(go.Bar(x=summary_df_sorted_p['Channel_name'], y=summary_df_sorted_p['new_efficiency'], 
+                                name='Optimized Efficiency',text=summary_df_sorted_p['new_efficiency'].apply(format_number),textposition='outside' , 
+                                marker_color=light_orange,showlegend=True))
+            
+            fig.update_xaxes(title_text="Channels")
+            fig.update_yaxes(title_text="ROI")
+            fig.update_layout(
+                title = "Actual vs. Optimized ROI",
+                        margin=dict(t=40, b=40, l=40, r=40),
+                        # yaxis=dict(range=[0, 0.002]),
+                    )
+                
+            st.plotly_chart(fig,use_container_width=True)
+
+
+    # Response Metrics
+    directory = "metrics_level_data"
+    metrics_list = get_excel_names(directory)
+    
+    # metrics_selected = col1.selectbox(
+    #     "Response Metrics",
+    #     metrics_list,
+    #     format_func=name_formating,
+    #     index=0,
+    #     on_change=reset_inputs,
+    # )
+
+    metrics_selected='prospects'
+    # Target
+    target = name_formating(metrics_selected)
+
+    file_selected = (
+        f"Overview_data_test_panel@#{metrics_selected}.xlsx"
+    )
+
+    # Panel List
+    panel_list = panel_fetch(file_selected)
+
+    # # Panel Selected
+    # panel_selected = st.selectbox(
+    #     "Markets",
+    #     ["Total Market"] + panel_list,
+    #     index=0,
+    #     on_change=reset_inputs,
+    # )
+    
+    # st.write(panel_selected)
+    panel_selected = "Total Market"
+    st.session_state['selected_markets']=panel_selected
+
+    if "update_rcs" in st.session_state:
+        updated_rcs = st.session_state["update_rcs"]
+    else:
+        updated_rcs = None
+
+    if "first_time" not in st.session_state:
+        st.session_state["first_time"] = True
+
+    # Check if state is initiaized
+    is_state_initiaized = st.session_state.get("initialized", False)
+    if not is_state_initiaized or st.session_state["first_time"]:
+        # initialize_data()
+        if panel_selected == "Total Market":
+            initialize_data(
+                panel=panel_selected,
+                target_file=file_selected,
+                updated_rcs=updated_rcs,
+                metrics=metrics_selected,
+            )
+            panel = None
+        else:
+            initialize_data(
+                panel=panel_selected,
+                target_file=file_selected,
+                updated_rcs=updated_rcs,
+                metrics=metrics_selected,
+            )
+        st.session_state["initialized"] = True
+        st.session_state["first_time"] = False
+
+    # initialize_data(
+    #             panel=panel_selected,
+    #             target_file=file_selected,
+    #             updated_rcs=updated_rcs,
+    #             metrics=metrics_selected,
+    #         )
+    # st.session_state["initialized"] = True
+    # st.session_state["first_time"] = False
+
+    # Channels List
+    channels_list = st.session_state["channels_list"]
+
+    # ======================================================== #
+    # ========================== UI ========================== #
+    # ======================================================== #
+
+    # print(list(st.session_state.keys()))
+    main_header = st.columns((2, 2))
+    sub_header = st.columns((1, 1, 1, 1))
+    _scenario = st.session_state["scenario"]
+
+    if "total_spends_change" not in st.session_state:
+        st.session_state.total_spends_change = 0
+
+    if "total_sales_change" not in st.session_state:
+        st.session_state.total_sales_change = 0
+
+    if "total_spends_change_abs" not in st.session_state:
+        st.session_state["total_spends_change_abs"] = numerize(
+            _scenario.actual_total_spends, 1
+        )
+
+    if "total_sales_change_abs" not in st.session_state:
+        st.session_state["total_sales_change_abs"] = numerize(
+            _scenario.actual_total_sales, 1
+        )
+
+    if "total_spends_change_abs_slider" not in st.session_state:
+        st.session_state.total_spends_change_abs_slider = numerize(
+            _scenario.actual_total_spends, 1
+        )
+
+    if "total_sales_change_abs_slider" not in st.session_state:
+        st.session_state.total_sales_change_abs_slider = numerize(
+            _scenario.actual_total_sales, 1
+        )
+
+    with main_header[0]:
+        st.subheader("Actual")
+
+    with main_header[-1]:
+        st.subheader("Simulated")
+
+    with sub_header[0]:
+        st.metric(label="Spends", value=format_numbers(_scenario.actual_total_spends))
+
+    with sub_header[1]:
+        st.metric(
+            label=target,
+            value=format_numbers_f(
+                float(_scenario.actual_total_sales)
+            ),
+        )
+
+    with sub_header[2]:
+        st.metric(
+            label="Spends",
+            value=format_numbers(_scenario.modified_total_spends),
+            delta=numerize(_scenario.delta_spends, 1),
+        )
+
+    with sub_header[3]:
+        st.metric(
+            label=target,
+            value=format_numbers_f(
+                float(_scenario.modified_total_sales)
+            ),
+            delta=numerize(_scenario.delta_sales, 1),
+        )
+
+    with st.expander("Channel Spends Simulator", expanded=True):
+        _columns1 = st.columns((2, 2, 1, 1))
+        with _columns1[0]:
+            optimization_selection = st.selectbox(
+                "Optimize", options=["Media Spends", target], key="optimization_key"
+            )
+
+        with _columns1[1]:
+            st.markdown("#")
+            # if st.checkbox(
+            #     label="Optimize all Channels",
+            #     key="optimze_all_channels",
+            #     value=False,
+            #     # on_change=select_all_channels_for_optimization,
+            # ):
+            #     select_all_channels_for_optimization()
+
+            st.checkbox(
+                label="Optimize all Channels",
+                key="optimze_all_channels",
+                value=False,
+                on_change=select_all_channels_for_optimization,
+            )
+
+        with _columns1[2]:
+            st.markdown("#")
+            # st.button(
+            #     "Optimize",
+            #     on_click=optimize,
+            #     args=(st.session_state["optimization_key"]),
+            #     use_container_width=True,
+            # )
+
+            optimize_placeholder = st.empty()
+
+        with _columns1[3]:
+            st.markdown("#")
+            st.button(
+                "Reset",
+                on_click=reset_scenario,
+                args=(panel_selected, file_selected, updated_rcs),
+                # use_container_width=True,
+            )
+            # st.write(target)
+
+
+        _columns2 = st.columns((2, 2, 2))
+        if st.session_state["optimization_key"] == "Media Spends":
+            with _columns2[0]:
+                spend_input = st.text_input(
+                    "Absolute",
+                    key="total_spends_change_abs",
+                    # label_visibility="collapsed",
+                    on_change=update_all_spends_abs,
+                )
+
+            with _columns2[1]:
+                st.number_input(
+                    "Percent Change",
+                    key="total_spends_change",
+                    min_value=-50,
+                    max_value=50,
+                    step=1,
+                    on_change=update_spends,
+                )
+
+            with _columns2[2]:
+                min_value = round(_scenario.actual_total_spends * 0.5)
+                max_value = round(_scenario.actual_total_spends * 1.5)
+                st.session_state["total_spends_change_abs_slider_options"] = [
+                    numerize(value, 1)
+                    for value in range(min_value, max_value + 1, int(1e4))
+                ]
+
+                # st.select_slider(
+                #     "Absolute Slider",
+                #     options=st.session_state["total_spends_change_abs_slider_options"],
+                #     key="total_spends_change_abs_slider",
+                #     on_change=update_all_spends_abs_slider,
+                # )
+        
+        elif st.session_state["optimization_key"] == target:
+            # st.write(target)
+            with _columns2[0]:
+                sales_input = st.text_input(
+                    "Absolute",
+                    key="total_sales_change_abs",
+                    on_change=update_sales_abs,
+                )
+
+            with _columns2[1]:
+                st.number_input(
+                    "Percent Change",
+                    key="total_sales_change",
+                    min_value=-50,
+                    max_value=50,
+                    step=1,
+                    on_change=update_sales,
+                )
+            with _columns2[2]:
+                min_value = round(_scenario.actual_total_sales * 0.5)
+                max_value = round(_scenario.actual_total_sales * 1.5)
+                st.write(min_value)
+                st.write(max_value)
+                # for value in range(min_value, max_value + 1, int(100)):
+                #     st.write(numerize(value, 1))
+                st.session_state["total_sales_change_abs_slider_options"] = [
+                    numerize(value, 1)
+                    for value in range(min_value, max_value + 1, int(100))
+                ]
+
+                st.select_slider(
+                    "Absolute Slider",
+                    options=st.session_state["total_sales_change_abs_slider_options"],
+                    key="total_sales_change_abs_slider",
+                    on_change=update_sales_abs_slider,
+                    # value=numerize(min_value, 1)
+                )
+
+        if (
+            not st.session_state["allow_sales_update"]
+            and optimization_selection == target
+        ):
+            st.warning("Invalid Input")
+
+        if (
+            not st.session_state["allow_spends_update"]
+            and optimization_selection == "Media Spends"
+        ):
+            st.warning("Invalid Input")
+
+        status_placeholder = st.empty()
+
+        # if optimize_placeholder.button("Optimize", use_container_width=True):
+        #     optimize(st.session_state["optimization_key"], status_placeholder)
+        #     st.rerun()
+
+        optimize_placeholder.button(
+            "Optimize",
+            on_click=optimize,
+            args=(st.session_state["optimization_key"], status_placeholder),
+            # use_container_width=True,
+        )
+
+        st.markdown("""<hr class="spends-heading-seperator">""", unsafe_allow_html=True)
+        _columns = st.columns((2.5, 2, 1.5, 1.5, 1))
+        with _columns[0]:
+            generate_spending_header("Channel")
+        with _columns[1]:
+            generate_spending_header("Spends Input")
+        with _columns[2]:
+            generate_spending_header("Spends")
+        with _columns[3]:
+            generate_spending_header(target)
+        with _columns[4]:
+            generate_spending_header("Optimize")
+
+        st.markdown("""<hr class="spends-heading-seperator">""", unsafe_allow_html=True)
+
+        if "acutual_predicted" not in st.session_state:
+            st.session_state["acutual_predicted"] = {
+                "Channel_name": [],
+                "Actual_spend": [],
+                "Optimized_spend": [],
+                "Delta": [],
+                "New_sales":[],
+                "Old_sales":[]
+            }
+        for i, channel_name in enumerate(channels_list):
+            # st.write(channel_name)
+            _channel_class = st.session_state["scenario"].channels[channel_name]
+            _columns = st.columns((2.5, 1.5, 1.5, 1.5, 1))
+            with _columns[0]:
+                st.write(channel_name_formating(channel_name))
+                bin_placeholder = st.container()
+
+            with _columns[1]:
+                channel_bounds = _channel_class.bounds
+                channel_spends = float(_channel_class.actual_total_spends)
+                min_value = float((1 + channel_bounds[0] / 100) * channel_spends)
+                max_value = float((1 + channel_bounds[1] / 100) * channel_spends)
+                ##print(st.session_state[channel_name])
+                spend_input = st.text_input(
+                    channel_name,
+                    key=channel_name,
+                    label_visibility="collapsed",
+                    on_change=partial(update_data, channel_name),
+                )
+                if not validate_input(spend_input):
+                    st.error("Invalid input")
+
+                channel_name_current = f"{channel_name}_change"
+
+                st.number_input(
+                    "Percent Change",
+                    key=channel_name_current,
+                    step=1,
+                    on_change=partial(update_data_by_percent, channel_name),
+                )
+
+            with _columns[2]:
+                # spends
+                current_channel_spends = float(
+                    _channel_class.modified_total_spends
+                    * _channel_class.conversion_rate
+                )
+                actual_channel_spends = float(
+                    _channel_class.actual_total_spends * _channel_class.conversion_rate
+                )
+                spends_delta = float(
+                    _channel_class.delta_spends * _channel_class.conversion_rate
+                )
+                st.session_state["acutual_predicted"]["Channel_name"].append(
+                    channel_name
+                )
+                st.session_state["acutual_predicted"]["Actual_spend"].append(
+                    actual_channel_spends
+                )
+                st.session_state["acutual_predicted"]["Optimized_spend"].append(
+                    current_channel_spends
+                )
+                st.session_state["acutual_predicted"]["Delta"].append(spends_delta)
+                ## REMOVE
+                st.metric(
+                    "Spends",
+                    format_numbers(current_channel_spends),
+                    delta=numerize(spends_delta, 1),
+                    label_visibility="collapsed",
+                )
+
+            with _columns[3]:
+                # sales
+                current_channel_sales = float(_channel_class.modified_total_sales)
+                actual_channel_sales = float(_channel_class.actual_total_sales)
+                sales_delta = float(_channel_class.delta_sales)
+                st.session_state["acutual_predicted"]["Old_sales"].append(actual_channel_sales)
+                st.session_state["acutual_predicted"]["New_sales"].append(current_channel_sales)
+                #st.write(actual_channel_sales)
+
+                st.metric(
+                    target,
+                    format_numbers_f(current_channel_sales),
+                    delta=numerize(sales_delta, 1),
+                    label_visibility="collapsed",
+                )
+
+            with _columns[4]:
+
+                # if st.checkbox(
+                #     label="select for optimization",
+                #     key=f"{channel_name}_selected",
+                #     value=False,
+                #     # on_change=partial(select_channel_for_optimization, channel_name),
+                #     label_visibility="collapsed",
+                # ):
+                #     select_channel_for_optimization(channel_name)
+
+                st.checkbox(
+                    label="select for optimization",
+                    key=f"{channel_name}_selected",
+                    value=False,
+                    on_change=partial(select_channel_for_optimization, channel_name),
+                    label_visibility="collapsed",
+                )
+
+            st.markdown(
+                """<hr class="spends-child-seperator">""",
+                unsafe_allow_html=True,
+            )
+
+            # Bins
+            col = channels_list[i]
+            x_actual = st.session_state["scenario"].channels[col].actual_spends
+            x_modified = st.session_state["scenario"].channels[col].modified_spends
+            # x_modified_total = 0 
+            # for c in channels_list:
+            #     # st.write(c)
+            #     # st.write(st.session_state["scenario"].channels[c].modified_spends)
+            #     x_modified_total = x_modified_total + st.session_state["scenario"].channels[c].modified_spends.sum()
+            # st.write(x_modified_total)
+            
+            x_total = x_modified.sum()
+            power = np.ceil(np.log(x_actual.max()) / np.log(10)) - 3
+
+            updated_rcs_key = f"{metrics_selected}#@{panel_selected}#@{channel_name}"
+
+            if updated_rcs and updated_rcs_key in list(updated_rcs.keys()):
+                K = updated_rcs[updated_rcs_key]["K"]
+                b = updated_rcs[updated_rcs_key]["b"]
+                a = updated_rcs[updated_rcs_key]["a"]
+                x0 = updated_rcs[updated_rcs_key]["x0"]
+            else:
+                K = st.session_state["rcs"][col]["K"]
+                b = st.session_state["rcs"][col]["b"]
+                a = st.session_state["rcs"][col]["a"]
+                x0 = st.session_state["rcs"][col]["x0"]
+
+            x_plot = np.linspace(0, 5 * x_actual.sum(), 200)
+
+            # Append current_channel_spends to the end of x_plot
+            x_plot = np.append(x_plot, current_channel_spends)
+
+            x, y, marginal_roi = [], [], []
+            for x_p in x_plot:
+                x.append(x_p * x_actual / x_actual.sum())
+
+            for index in range(len(x_plot)):
+                y.append(s_curve(x[index] / 10**power, K, b, a, x0))
+
+            for index in range(len(x_plot)):
+                marginal_roi.append(
+                    a * y[index] * (1 - y[index] / np.maximum(K, np.finfo(float).eps))
+                )
+
+            x = (
+                np.sum(x, axis=1)
+                * st.session_state["scenario"].channels[col].conversion_rate
+            )
+            y = np.sum(y, axis=1)
+            marginal_roi = (
+                np.average(marginal_roi, axis=1)
+                / st.session_state["scenario"].channels[col].conversion_rate
+            )
+
+            roi = y / np.maximum(x, np.finfo(float).eps)
+            # roi = (y/np.sum(y))/(x/np.sum(x))
+            # st.write(x)
+            # st.write(y)
+            # st.write(roi)
+
+            # st.write(roi[-1])
+            
+            roi_current, marginal_roi_current = roi[-1], marginal_roi[-1]
+            x, y, roi, marginal_roi = (
+                x[:-1],
+                y[:-1],
+                roi[:-1],
+                marginal_roi[:-1],
+            )  # Drop data for current spends
+
+            # roi_current = 
+
+            start_value, end_value, left_value, right_value = find_segment_value(
+                x,
+                roi,
+                marginal_roi,
+            )
+
+            #st.write(roi_current)
+
+            rgba = calculate_rgba(
+                start_value,
+                end_value,
+                left_value,
+                right_value,
+                current_channel_spends,
+            )
+
+            summary_df = pd.DataFrame(st.session_state["acutual_predicted"])
+            # st.dataframe(summary_df)
+            summary_df.drop_duplicates(subset="Channel_name", keep="last", inplace=True)
+            # st.dataframe(summary_df)
+
+            summary_df_sorted = summary_df.sort_values(by="Delta", ascending=False)
+            summary_df_sorted["Delta_percent"] = np.round(
+                ((summary_df_sorted["Optimized_spend"] / summary_df_sorted["Actual_spend"]) - 1)
+                * 100,
+                2,
+            )
+
+            summary_df_sorted=summary_df_sorted.sort_values(by=['Optimized_spend'],ascending=False)
+            summary_df_sorted['old_efficiency']=(summary_df_sorted['Old_sales']/summary_df_sorted['Old_sales'].sum())/(summary_df_sorted['Actual_spend']/summary_df_sorted['Actual_spend'].sum())
+            summary_df_sorted['new_efficiency']=(summary_df_sorted['New_sales']/summary_df_sorted['New_sales'].sum())/(summary_df_sorted['Optimized_spend']/summary_df_sorted['Optimized_spend'].sum())
+            
+            a = (summary_df_sorted[summary_df_sorted['Channel_name']== col]).reset_index()['new_efficiency'][0]
+            # st.write(a)
+
+            with bin_placeholder:
+                if a> 1:
+                    fill_color_box = "#98fb98"
+                elif a <1:
+                    fill_color_box = "#ff6868"
+                else: 
+                    fill_color_box = "#ff6868"
+                st.markdown(
+                    f"""
+                    <div style="
+                        border-radius: 12px;
+                        background-color: {fill_color_box};
+                        padding: 10px;
+                        text-align: center;
+                        color: {'black'};
+                        ">
+                        <p style="margin: 0; font-size: 20px;">Efficiency: {round(a,2)}</p>
+                        <!--<p style="margin: 0; font-size: 20px;">Marginal ROI: {round(marginal_roi_current,1)}</p>-->
+                    </div>
+                    """,
+                    unsafe_allow_html=True,
+                )
+
+    with st.expander("See Response Curves", expanded=True):
+        fig = plot_response_curves(summary_df_sorted)
+        # st.plotly_chart(rc.response_curves(col))
+        # st.plotly_chart(fig, use_container_width=True)
+
+    summary_df = pd.DataFrame(st.session_state["acutual_predicted"])
+    # st.dataframe(summary_df)
+    summary_df.drop_duplicates(subset="Channel_name", keep="last", inplace=True)
+    # st.dataframe(summary_df)
+
+    summary_df_sorted = summary_df.sort_values(by="Delta", ascending=False)
+    summary_df_sorted["Delta_percent"] = np.round(
+        ((summary_df_sorted["Optimized_spend"] / summary_df_sorted["Actual_spend"]) - 1)
+        * 100,
+        2,
+    )
+
+    
+
+    
+
+    with open("summary_df.pkl", "wb") as f:
+        pickle.dump(summary_df_sorted, f)
+        # st.dataframe(summary_df_sorted)
+        # ___columns=st.columns(3)
+        # with ___columns[2]:
+        #     fig=summary_plot(summary_df_sorted, x='Delta_percent', y='Channel_name', title='Delta', text_column='Delta_percent')
+        #     st.plotly_chart(fig,use_container_width=True)
+        # with ___columns[0]:
+        #     fig=summary_plot(summary_df_sorted, x='Actual_spend', y='Channel_name', title='Actual Spend', text_column='Actual_spend')
+        #     st.plotly_chart(fig,use_container_width=True)
+        # with ___columns[1]:
+        #     fig=summary_plot(summary_df_sorted, x='Optimized_spend', y='Channel_name', title='Planned Spend', text_column='Optimized_spend')
+        #     st.plotly_chart(fig,use_container_width=True)
+
+    scenario_planner_plots()
+
+    _columns = st.columns(2)
+    # with _columns[0]:
+    st.subheader("Save Scenario")
+    scenario_name = st.text_input(
+        "Scenario name",
+        key="scenario_input",
+        placeholder="Scenario name",
+        label_visibility="collapsed",
+    )
+    st.button(
+        "Save",
+        on_click=lambda: save_scenario(scenario_name),
+        disabled=len(st.session_state["scenario_input"]) == 0,#use_container_width=True
+    )
+
+
+
+elif auth_status == False:
+    st.error("Username/Password is incorrect")
+
+if auth_status != True:
+    try:
+        username_forgot_pw, email_forgot_password, random_password = (
+            authenticator.forgot_password("Forgot password")
+        )
+        if username_forgot_pw:
+            st.session_state["config"]["credentials"]["usernames"][username_forgot_pw][
+                "password"
+            ] = stauth.Hasher([random_password]).generate()[0]
+            send_email(email_forgot_password, random_password)
+            st.success("New password sent securely")
+            # Random password to be transferred to user securely
+        elif username_forgot_pw == False:
+            st.error("Username not found")
+    except Exception as e:
+        st.error(e)

pages/3_Saved_Scenarios.py

@@ -0,0 +1,420 @@
+import streamlit as st
+from numerize.numerize import numerize
+import io
+import pandas as pd
+from utilities import (format_numbers,decimal_formater,
+                       channel_name_formating,
+                       load_local_css,set_header,
+                       initialize_data,
+                       load_authenticator)
+from openpyxl import Workbook
+from openpyxl.styles import Alignment,Font,PatternFill
+import pickle
+import streamlit_authenticator as stauth
+import yaml
+from yaml import SafeLoader
+from classes import class_from_dict
+import plotly.graph_objects as go
+
+st.set_page_config(layout='wide')
+load_local_css('styles.css')
+set_header()
+
+# for k, v in st.session_state.items():
+#     if k not in ['logout', 'login','config'] and not k.startswith('FormSubmitter'):
+#         st.session_state[k] = v
+def comparision_scenarios_df():
+    
+    ## create summary page
+    if len(scenarios_to_compare) == 0:
+        return
+    summary_df_spend = None
+    summary_df_prospect = None
+    # summary_df_efficiency = None
+    #=print(scenarios_to_download)
+    for scenario_name in scenarios_to_compare:
+        scenario_dict =  st.session_state['saved_scenarios'][scenario_name]
+        _spends = []
+        column_names = ['Date']
+        _sales = None
+        dates = None
+        summary_rows_spend = []
+        summary_rows_prospects = []
+        for channel in scenario_dict['channels']:
+            if dates is None:
+                dates = channel.get('dates')
+                _spends.append(dates)
+            if _sales is None:
+                _sales = channel.get('modified_sales')
+            else:
+                _sales += channel.get('modified_sales')
+            _spends.append(channel.get('modified_spends') * channel.get('conversion_rate'))
+            column_names.append(channel.get('name'))
+            
+            name_mod = channel_name_formating(channel['name'])
+            summary_rows_spend.append([name_mod,
+                                channel.get('modified_total_spends') * channel.get('conversion_rate')])
+            summary_rows_prospects.append([name_mod,
+                                channel.get('modified_total_sales')])
+
+        _spends.append(_sales)
+        # column_names.append('NRPU')
+        # scenario_df = pd.DataFrame(_spends).T
+        # scenario_df.columns = column_names
+           
+        # summary_rows.append(['Total',
+                        # scenario_dict.get('modified_total_spends') ,
+                        # scenario_dict.get('modified_total_sales'),
+                        # scenario_dict.get('modified_total_sales') / scenario_dict.get('modified_total_spends'),
+                        # '-',
+                        # scenario_dict.get('modified_total_spends') / scenario_dict.get('modified_total_sales')])
+        # columns_index = pd.MultiIndex.from_product([[''],['Channel']], names=["first", "second"])
+        # columns_index = columns_index.append(pd.MultiIndex.from_product([[scenario_name],['Spends','NRPU','ROI','MROI','Spends per NRPU']], names=["first", "second"]))
+        columns_index = ['Channel',scenario_name]
+        if summary_df_spend is None:
+            summary_df_spend = pd.DataFrame(summary_rows_spend, columns = columns_index)
+            summary_df_spend = summary_df_spend.set_index('Channel')
+        else:
+            _df = pd.DataFrame(summary_rows_spend, columns = columns_index)
+            _df = _df.set_index('Channel')
+            summary_df_spend = summary_df_spend.merge(_df, left_index=True, right_index=True)
+
+        if summary_df_prospect is None:
+            summary_df_prospect = pd.DataFrame(summary_rows_prospects, columns = columns_index)
+            summary_df_prospect = summary_df_prospect.set_index('Channel')
+        else:
+            _df = pd.DataFrame(summary_rows_prospects, columns = columns_index)
+            _df = _df.set_index('Channel')
+            summary_df_prospect = summary_df_prospect.merge(_df, left_index=True, right_index=True)
+    st.session_state['disable_download_button'] = False
+    return summary_df_spend,summary_df_prospect
+
+
+
+def plot_comparision_chart(df,metric):
+    
+    # Create traces for each column
+    traces = []
+    for column in df.columns:
+        traces.append(go.Bar(
+            x=df.index,
+            y=df[column],
+            name=column,
+            text=df[column].apply(numerize),  # Adding text for each point
+            textposition='outside', 
+            hoverinfo='x+y+text',
+        ))
+
+    # Create the layout
+    layout = go.Layout(
+        title='Scenario Comparision '+ metric,
+        xaxis_title="Channels",
+        yaxis_title=metric,
+        barmode='group'
+    )
+
+    # Create the figure
+    fig = go.Figure(data=traces, layout=layout)
+
+    return fig
+
+def create_comparision_plots():
+    comparision_scenarios_df()
+    spends_df, prospects_df = comparision_scenarios_df()
+
+    st.plotly_chart(plot_comparision_chart(spends_df,"Spends"),use_container_width=True)
+    st.plotly_chart(plot_comparision_chart(prospects_df,"Contributions"),use_container_width=True)
+
+def create_scenario_summary(scenario_dict):
+    summary_rows = []
+    actual_total_spends = scenario_dict.get('actual_total_spends'), 
+    modified_total_spends = scenario_dict.get('modified_total_spends'),
+    actual_total_sales = scenario_dict.get('actual_total_sales'), 
+    modified_total_sales = scenario_dict.get('modified_total_sales')
+    # st.write(modified_total_spends[0])
+    # st.write(actual_total_spends[0])
+    # st.write(modified_total_sales)
+    # st.write(actual_total_sales[0])
+    # st.write(modified_total_spends[0])
+    for channel_dict in scenario_dict['channels']:
+        name_mod = channel_name_formating(channel_dict['name'])
+        summary_rows.append([name_mod,
+                             channel_dict.get('actual_total_spends') * channel_dict.get('conversion_rate'),
+                             channel_dict.get('modified_total_spends') * channel_dict.get('conversion_rate'),
+                             channel_dict.get('actual_total_sales') ,
+                             channel_dict.get('modified_total_sales'),
+                            #  channel_dict.get('modified_total_sales')/modified_total_spends[0],
+                            #  channel_dict.get('modified_total_sales')/modified_total_spends[0]
+
+                            #  1,2
+                            (channel_dict.get('actual_total_sales') /actual_total_sales[0])/(channel_dict.get('actual_total_spends') /actual_total_spends[0] ),
+                            (channel_dict.get('modified_total_sales') /modified_total_sales )/(channel_dict.get('modified_total_spends') /modified_total_spends[0] )      
+                            #   #                       #  channel_dict.get('actual_mroi'), 
+                            #  channel_dict.get('modified_mroi'),
+                            #  channel_dict.get('actual_total_spends') * channel_dict.get('conversion_rate') / channel_dict.get('actual_total_sales'),
+                            #  channel_dict.get('modified_total_spends') * channel_dict.get('conversion_rate') / channel_dict.get('modified_total_sales')
+                            ])
+        
+    summary_rows.append(['Total',
+                         scenario_dict.get('actual_total_spends'), 
+                         scenario_dict.get('modified_total_spends'),
+                         scenario_dict.get('actual_total_sales'), 
+                         scenario_dict.get('modified_total_sales'),
+                         1.0,
+                         1.0
+                        #  scenario_dict.get('actual_total_sales') / scenario_dict.get('actual_total_spends'),
+                        #  scenario_dict.get('modified_total_sales') / scenario_dict.get('modified_total_spends'),
+                        #  '-',
+                        #  '-',
+                        #  scenario_dict.get('actual_total_spends') / scenario_dict.get('actual_total_sales'),
+                        #  scenario_dict.get('modified_total_spends') / scenario_dict.get('modified_total_sales')
+                        ])
+    
+    columns_index = pd.MultiIndex.from_product([[''],['Channel']], names=["first", "second"])
+    columns_index = columns_index.append(pd.MultiIndex.from_product([['Spends','Prospects',"Efficiency"],['Actual','Simulated']], names=["first", "second"]))
+    
+    return  pd.DataFrame(summary_rows, columns=columns_index)
+    
+
+   
+def summary_df_to_worksheet(df, ws):
+    heading_fill = PatternFill(fill_type='solid',start_color='FF11B6BD',end_color='FF11B6BD')
+    for j,header in enumerate(df.columns.values):
+        col = j + 1
+        for i in range(1,3):
+            ws.cell(row=i, column=j + 1, value=header[i - 1]).font = Font(bold=True, color='FF11B6BD')
+            ws.cell(row=i,column=j+1).fill = heading_fill
+        if  col > 1 and (col - 6)%5==0:    
+            ws.merge_cells(start_row=1, end_row=1, start_column = col-3, end_column=col)
+            ws.cell(row=1,column=col).alignment = Alignment(horizontal='center')
+    for i,row in enumerate(df.itertuples()):
+        for j,value in enumerate(row):
+            if j == 0:
+                continue
+            elif (j-2)%4 == 0 or (j-3)%4 == 0:
+                ws.cell(row=i+3, column = j, value=value).number_format = '$#,##0.0' 
+            else:
+                ws.cell(row=i+3, column = j, value=value)
+   
+from openpyxl.utils import get_column_letter
+from openpyxl.styles import Font, PatternFill
+import logging
+
+def scenario_df_to_worksheet(df, ws):
+    heading_fill = PatternFill(start_color='FF11B6BD', end_color='FF11B6BD', fill_type='solid')
+    
+    for j, header in enumerate(df.columns.values):
+        cell = ws.cell(row=1, column=j + 1, value=header)
+        cell.font = Font(bold=True, color='FF11B6BD')
+        cell.fill = heading_fill
+
+    for i, row in enumerate(df.itertuples()):
+        for j, value in enumerate(row[1:], start=1):  # Start from index 1 to skip the index column
+            try:
+                cell = ws.cell(row=i + 2, column=j, value=value)
+                if isinstance(value, (int, float)):
+                    cell.number_format = '$#,##0.0'
+                elif isinstance(value, str):
+                    cell.value = value[:32767]
+                else:
+                    cell.value = str(value)
+            except ValueError as e:
+                logging.error(f"Error assigning value '{value}' to cell {get_column_letter(j)}{i+2}: {e}")
+                cell.value = None  # Assign None to the cell where the error occurred
+
+    return ws
+
+
+
+
+
+   
+def download_scenarios():
+    """
+    Makes a excel with all saved scenarios and saves it locally
+    """
+    ## create summary page
+    if len(scenarios_to_download) == 0:
+        return
+    wb = Workbook()
+    wb.iso_dates = True
+    wb.remove(wb.active)
+    st.session_state['xlsx_buffer'] = io.BytesIO()
+    summary_df = None
+    #print(scenarios_to_download)
+    for scenario_name in scenarios_to_download:
+        scenario_dict =  st.session_state['saved_scenarios'][scenario_name]
+        _spends = []
+        column_names = ['Date']
+        _sales = None
+        dates = None
+        summary_rows = []
+        for channel in scenario_dict['channels']:
+            if dates is None:
+                dates = channel.get('dates')
+                _spends.append(dates)
+            if _sales is None:
+                _sales = channel.get('modified_sales')
+            else:
+                _sales += channel.get('modified_sales')
+            _spends.append(channel.get('modified_spends') * channel.get('conversion_rate'))
+            column_names.append(channel.get('name'))
+            
+            name_mod = channel_name_formating(channel['name'])
+            summary_rows.append([name_mod,
+                                channel.get('modified_total_spends') * channel.get('conversion_rate') ,
+                                channel.get('modified_total_sales'),
+                                channel.get('modified_total_sales') / channel.get('modified_total_spends') * channel.get('conversion_rate'),
+                                channel.get('modified_mroi'),
+                                channel.get('modified_total_sales') / channel.get('modified_total_spends') * channel.get('conversion_rate')])
+        _spends.append(_sales)
+        column_names.append('NRPU')
+        scenario_df = pd.DataFrame(_spends).T
+        scenario_df.columns = column_names
+        ## write to sheet
+        ws = wb.create_sheet(scenario_name)
+        scenario_df_to_worksheet(scenario_df, ws)    
+        summary_rows.append(['Total',
+                        scenario_dict.get('modified_total_spends') ,
+                        scenario_dict.get('modified_total_sales'),
+                        scenario_dict.get('modified_total_sales') / scenario_dict.get('modified_total_spends'),
+                        '-',
+                        scenario_dict.get('modified_total_spends') / scenario_dict.get('modified_total_sales')])
+        columns_index = pd.MultiIndex.from_product([[''],['Channel']], names=["first", "second"])
+        columns_index = columns_index.append(pd.MultiIndex.from_product([[scenario_name],['Spends','NRPU','ROI','MROI','Spends per NRPU']], names=["first", "second"]))
+        if summary_df is None:
+            summary_df = pd.DataFrame(summary_rows, columns = columns_index)
+            summary_df = summary_df.set_index(('','Channel'))
+        else:
+            _df = pd.DataFrame(summary_rows, columns = columns_index)
+            _df = _df.set_index(('','Channel'))
+            summary_df = summary_df.merge(_df, left_index=True, right_index=True)
+    ws = wb.create_sheet('Summary',0)
+    summary_df_to_worksheet(summary_df.reset_index(), ws)
+    wb.save(st.session_state['xlsx_buffer'])
+    st.session_state['disable_download_button'] = False
+
+def disable_download_button():
+    st.session_state['disable_download_button'] =True
+
+def transform(x):
+    if x.name == ("",'Channel'):
+        return x
+    elif x.name[0] == 'ROI' or x.name[0] == 'MROI':
+        return x.apply(lambda y : y if isinstance(y,str) else decimal_formater(format_numbers(y,include_indicator=False,n_decimals=4),n_decimals=4))
+    else:
+        return x.apply(lambda y : y if isinstance(y,str) else format_numbers(y))
+
+def delete_scenario():
+    if selected_scenario in st.session_state['saved_scenarios']:
+        del st.session_state['saved_scenarios'][selected_scenario]
+        with open('../saved_scenarios.pkl', 'wb') as f:
+            pickle.dump(st.session_state['saved_scenarios'],f)     
+            
+def load_scenario():
+    if selected_scenario in st.session_state['saved_scenarios']:
+        st.session_state['scenario'] = class_from_dict(selected_scenario_details)
+        
+
+
+authenticator = st.session_state.get('authenticator')
+if authenticator is None:
+    authenticator = load_authenticator()
+
+name, authentication_status, username = authenticator.login('Login', 'main')
+auth_status = st.session_state.get('authentication_status')
+
+if auth_status == True:
+    is_state_initiaized = st.session_state.get('initialized',False)
+    if not is_state_initiaized:
+        #print("Scenario page state reloaded")
+        initialize_data()
+
+
+    saved_scenarios = st.session_state['saved_scenarios']
+
+
+    if len(saved_scenarios) ==0:
+        st.header('No saved scenarios')
+        
+    else:
+        
+        with st.sidebar:
+            with st.expander('View Scenario Details'):
+                st.markdown("""<hr>""", unsafe_allow_html=True)
+                selected_scenario = st.selectbox('Select the scenario',list(saved_scenarios.keys()))
+                # selected_scenario = st.radio(
+                #     'Pick a scenario to view details',
+                #     list(saved_scenarios.keys())
+                # )
+            with st.expander('Download Scenario'):
+                st.markdown("""<hr>""", unsafe_allow_html=True)
+                scenarios_to_download = st.multiselect('Select scenarios to download',
+                            list(saved_scenarios.keys()))
+            
+                st.button('Prepare download',on_click=download_scenarios)
+                st.download_button(
+                        label="Download Scenarios",
+                        data=st.session_state['xlsx_buffer'].getvalue(),
+                        file_name="scenarios.xlsx",
+                        mime="application/vnd.ms-excel",
+                        disabled= st.session_state['disable_download_button'],
+                        on_click= disable_download_button
+                    )
+            with st.expander('Compare Scenarios'):
+                st.markdown("""<hr>""", unsafe_allow_html=True)
+                scenarios_to_compare = st.multiselect('Select scenarios to compare',
+                            list(saved_scenarios.keys()))                
+                st.button('Compare')
+                
+            
+        column_1, column_2,column_3 = st.columns((6,1,1))
+        with column_1:
+            st.header(selected_scenario)
+        with column_2:
+            st.button('Delete scenarios', on_click=delete_scenario)
+        with column_3:
+            st.button('Load Scenario', on_click=load_scenario)
+        
+        selected_scenario_details = saved_scenarios[selected_scenario]
+        
+        pd.set_option('display.max_colwidth', 100)
+            
+        st.markdown(create_scenario_summary(selected_scenario_details).transform(transform).style.set_table_styles(
+    [{
+        'selector': 'th',
+        'props': [('background-color', '#11B6BD')]
+    },
+        {
+        'selector' : 'tr:nth-child(even)',
+        'props' : [('background-color', '#11B6BD')]
+        }
+        ]).to_html(),unsafe_allow_html=True)
+        st.markdown("<br><br>", unsafe_allow_html=True)
+        
+        with st.expander('Scenario Comparision'):
+            st.header("Scenario Comparision")
+            if len(scenarios_to_compare)== 0:
+                st.write("")
+            else:
+                create_comparision_plots()
+        
+elif auth_status == False:
+    st.error('Username/Password is incorrect')
+    
+if auth_status != True:
+    try:
+        username_forgot_pw, email_forgot_password, random_password = authenticator.forgot_password('Forgot password')
+        if username_forgot_pw:
+            st.success('New password sent securely')
+            # Random password to be transferred to user securely
+        elif username_forgot_pw == False:
+            st.error('Username not found')
+    except Exception as e:
+        st.error(e)
+
+
+
+
+
+# create_comparision_plots()

pages/4_Model Quality.py

@@ -0,0 +1,57 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import Streamlit_functions as sf
+import response_curves_model_quality_base as rc1
+st.set_page_config(
+    layout="wide"
+)   
+
+
+st.header("Model Quality")
+st.write("MMM Model Quality")
+
+st.plotly_chart(sf.mmm_model_quality(),use_container_width=True)
+    
+media_df = sf.media_data()
+    # Create two columns for start date and end date input
+col1, col2 = st.columns(2)
+
+st.table(sf.model_metrics_table_func()) 
+
+with col1:
+    st.plotly_chart(sf.elasticity(media_df))
+with col2:
+    st.plotly_chart(sf.half_life(media_df))
+    
+
+# Dropdown menu options
+options = [
+    'Broadcast TV',
+    'Cable TV',
+    'Connected & OTT TV',
+    'Display Prospecting',
+    'Display Retargeting',
+    'Video',
+    'Social Prospecting',
+    'Social Retargeting',
+    'Search Brand',
+    'Search Non-brand',
+    'Digital Partners',
+    'Audio',
+    'Email']
+options1 = [
+    'View Line Plot',
+    'View Scattered Plot',
+    "View Both"]
+col1, col2 = st.columns(2)
+     # Create a dropdown menu   
+with col1:
+    selected_option = st.selectbox('Select a media channel:', options)
+    selected_option2 = st.selectbox('Select a Chart Type', options1)
+         # Display the selected option
+    st.plotly_chart(rc1.response_curves(selected_option,selected_option2))
+with col2:
+    st.write("")
+   

pages/5_Glossary.py

@@ -0,0 +1,33 @@
+import streamlit as st
+
+# st.set_page_config(
+#     layout="wide"
+# )
+
+def glossary_run():
+    st.subheader("Glossary of MMM Terminology")
+    st.write("**• Model R-squared \(R\)\:** This is a statistical measure used to determine the percentage of variation in the dependent variable that the independent variables explain collectively. It ranges between 0 and 1, where 1 indicates a perfect fit and 0 indicates no linear relationship. An R2 greater than 0.8 usually indicates a great model fit.")
+
+    st.write("**• Mean Absolute Percentage Error \(MAPE\):** This is a measure used to determine the accuracy of a predictive model. It calculates the average absolute percentage difference between the actual and predicted values, expressing the result as a percentage to provide a sense of scale for the error.")
+
+    st.write("**• Media & Baseline Elasticity:** It refers to the percentage change in the number of prospects in response to a percentage change in a marketing input \(media channel spends\) or a baseline factor \(like seasonality. macro factors, competitors spending, etc.\). It is a measure of the responsiveness of the number of prospects to changes in the marketing input or the baseline factor")
+
+    st.write("**• Media Half-Life:** This represents the time it takes for a media spend's impact to reduce to half of its initial impact. It is a key aspect of media decay rates, which represent how the effect of advertising diminishes over time \(in weeks\). This term refers to a curve that illustrates the relationship between media spend and the resulting number of prospects.")
+
+    st.write("**• Support:** Equivalent to Impression or Click depending on the media channel.")
+
+    st.write("**• Contribution Share:** Unit is %. It refers to the percentage contribution of a specific marketing channel to the number of prospects. It is calculated by dividing the contribution from a particular channel by the total number of prospects from all media channels \(not including base contributions\).")
+
+    st.write("**• Spend Share:** Unit is %. It refers to the percentage of the total marketing budget that is allocated to a specific marketing channel. It is calculated by dividing the amount spent on a particular channel by the total marketing spend")
+
+    st.write("**• Support Share:** Unit is %. It refers to the percentage of the total media impression that is allocated to a specific marketing channel. It is calculated by dividing support on a particular channel by the total marketing spend")
+
+    st.write("**• Efficiency Index:** it is a metric that measures the cost-effectiveness of a campaign. It is calculated by dividing Contribution Share by Spend Share. An efficiency index above 1 suggests that a channel is more cost-effective than the benchmark, while an efficiency index below 1 suggests it is less cost-effective. The higher the efficiency index, the more cost-effective its channel is")
+
+    st.write("**• Effectiveness Index:** It is a metric that measures how well a particular marketing channel is performing relative to its support/impression. It is calculated by dividing the Contribution Share by the Spend Share for each channel")
+
+    st.write("**• Estimated CPM \(Cost Per Thousand Impressions\):** This is an estimation of the cost for every thousand impressions \(or views\) of its advertisement via that media channel. The default values are generated from historical averages.")
+
+    st.write("**• Estimated CPC \(Cost Per Click\):** This is an estimation of the cost for each time someone clicks on its advertisement via that media channel. The default values are generated from historical averages.")
+
+glossary_run()

response_curves_model_quality.py

@@ -0,0 +1,489 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.optimize import curve_fit
+from sklearn.preprocessing import MinMaxScaler
+import warnings
+warnings.filterwarnings("ignore")
+import plotly.graph_objects as go
+
+## reading input data
+df= pd.read_csv('response_curves_input_file.csv')
+df.dropna(inplace=True)
+df['Date'] = pd.to_datetime(df['Date'])
+df.reset_index(inplace=True)
+
+channel_cols = [
+    'BroadcastTV',
+    'CableTV',
+    'Connected&OTTTV',
+    'DisplayProspecting',
+    'DisplayRetargeting',
+        'Video',
+    'SocialProspecting',
+    'SocialRetargeting',
+    'SearchBrand',
+    'SearchNon-brand',
+    'DigitalPartners',
+    'Audio',
+    'Email']
+spend_cols = [
+'tv_broadcast_spend', 
+'tv_cable_spend',
+    'stream_video_spend', 
+    'disp_prospect_spend', 
+    'disp_retarget_spend',
+       'olv_spend', 
+        'social_prospect_spend', 
+        'social_retarget_spend',
+       'search_brand_spend', 
+    'search_nonbrand_spend', 
+    'cm_spend',
+       'audio_spend',
+        'email_spend']
+prospect_cols = [
+        'Broadcast TV_Prospects',
+       'Cable TV_Prospects', 
+    'Connected & OTT TV_Prospects', 
+       'Display Prospecting_Prospects', 
+    'Display Retargeting_Prospects',
+    'Video_Prospects',
+       'Social Prospecting_Prospects', 
+    'Social Retargeting_Prospects',
+       'Search Brand_Prospects', 
+    'Search Non-brand_Prospects',
+       'Digital Partners_Prospects',
+    'Audio_Prospects', 
+    'Email_Prospects']
+
+def hill_equation(x, Kd, n):
+    return x**n / (Kd**n + x**n)
+
+
+def hill_func(x_data,y_data,x_minmax,y_minmax):
+    # Fit the Hill equation to the data
+    initial_guess = [1, 1]  # Initial guess for Kd and n
+    params, covariance = curve_fit(hill_equation, x_data, y_data, p0=initial_guess,maxfev = 1000)
+
+    # Extract the fitted parameters
+    Kd_fit, n_fit = params
+    
+
+    # Generate y values using the fitted parameters
+    y_fit = hill_equation(x_data, Kd_fit, n_fit)
+
+    x_data_inv = x_minmax.inverse_transform(np.array(x_data).reshape(-1,1))
+    y_data_inv = y_minmax.inverse_transform(np.array(y_data).reshape(-1,1))
+    y_fit_inv = y_minmax.inverse_transform(np.array(y_fit).reshape(-1,1))
+
+#     # Plot the original data and the fitted curve
+#     plt.scatter(x_data_inv, y_data_inv, label='Actual Data')
+#     plt.scatter(x_data_inv, y_fit_inv, label='Fit Data',color='red')
+#     # plt.line(x_data_inv, y_fit_inv, label=f'Fitted Hill Equation (Kd={Kd_fit:.2f}, n={n_fit:.2f})', color='red')
+#     plt.xlabel('Ligand Concentration')
+#     plt.ylabel('Fraction of Binding')
+#     plt.title('Fitting Hill Equation to Data')
+#     plt.legend()
+#     plt.show()
+
+    return y_fit,y_fit_inv,Kd_fit, n_fit
+
+def data_output(channel,X,y,y_fit_inv,x_ext_data,y_fit_inv_ext): 
+    fit_col = 'Fit_Data_'+channel
+    plot_df = pd.DataFrame()
+   
+    plot_df[f'{channel}_Spends'] = X
+
+    plot_df['Date'] = df['Date']
+    plot_df['MAT'] = df['MAT']
+    
+    
+
+    y_fit_inv_v2 = []
+    for i in range(len(y_fit_inv)):
+        y_fit_inv_v2.append(y_fit_inv[i][0])
+        
+    plot_df[fit_col] = y_fit_inv_v2
+    
+#     adding extra data
+
+    y_fit_inv_v2_ext = []
+    for i in range(len(y_fit_inv_ext)):
+        y_fit_inv_v2_ext.append(y_fit_inv_ext[i][0])
+    
+#     print(x_ext_data)
+    ext_df = pd.DataFrame()
+    ext_df[f'{channel}_Spends'] = x_ext_data
+    ext_df[fit_col] = y_fit_inv_v2_ext
+    
+    ext_df['Date'] =  [
+                    np.datetime64('1950-01-01'),
+                    np.datetime64('1950-06-15'),
+                    np.datetime64('1950-12-31')
+                ]
+
+    ext_df['MAT'] = ["ext","ext","ext"]
+    
+    print(ext_df)
+    plot_df= plot_df.append(ext_df)
+    return plot_df
+
+def input_data(df,spend_col,prospect_col):  
+    X = np.array(df[spend_col].tolist())
+    y = np.array(df[prospect_col].tolist())
+
+    x_minmax = MinMaxScaler()
+    x_scaled = x_minmax.fit_transform(df[[spend_col]])
+    x_data = []
+    for i in range(len(x_scaled)):
+        x_data.append(x_scaled[i][0])
+
+    y_minmax = MinMaxScaler()
+    y_scaled =  y_minmax.fit_transform(df[[prospect_col]])
+    y_data = []
+    for i in range(len(y_scaled)):
+        y_data.append(y_scaled[i][0])
+
+    return X,y,x_data,y_data,x_minmax,y_minmax
+
+def extend_s_curve(x_max,x_minmax,y_minmax, Kd_fit, n_fit):
+    print(x_max)
+    x_ext_data = [x_max*1.2,x_max*1.3,x_max*1.5]
+#     x_ext_data = [1500000,2000000,2500000]
+#     x_ext_data = [x_max+100,x_max+200,x_max+5000]
+    x_scaled = x_minmax.transform(pd.DataFrame(x_ext_data))
+    x_data = []
+    for i in range(len(x_scaled)):
+        x_data.append(x_scaled[i][0])
+        
+    print(x_data)
+    y_fit = hill_equation(x_data, Kd_fit, n_fit)
+    y_fit_inv = y_minmax.inverse_transform(np.array(y_fit).reshape(-1,1))
+    
+    return x_ext_data,y_fit_inv
+    
+def fit_data(spend_col,prospect_col,channel):
+    ### getting k and n parameters
+    temp_df = df[df[spend_col]>0]
+    temp_df.reset_index(inplace=True)
+
+    X,y,x_data,y_data,x_minmax,y_minmax = input_data(temp_df,spend_col,prospect_col)
+    y_fit, y_fit_inv, Kd_fit, n_fit = hill_func(x_data,y_data,x_minmax,y_minmax)
+    print('k: ',Kd_fit)
+    print('n: ', n_fit)
+    
+    ##### extend_s_curve
+    x_ext_data,y_fit_inv_ext=  extend_s_curve(temp_df[spend_col].max(),x_minmax,y_minmax, Kd_fit, n_fit)
+    
+    plot_df = data_output(channel,X,y,y_fit_inv,x_ext_data,y_fit_inv_ext)
+    return plot_df
+
+plotly_data = fit_data(spend_cols[0],prospect_cols[0],channel_cols[0])
+plotly_data.tail()
+
+for i in range(1,13):
+    print(i)
+    pdf =  fit_data(spend_cols[i],prospect_cols[i],channel_cols[i])
+    plotly_data = plotly_data.merge(pdf,on = ["Date","MAT"],how = "left")
+    
+def response_curves(channel,x_modified,y_modified):
+
+    # Initialize the Plotly figure
+    fig = go.Figure()
+
+    x_col = (channel+"_Spends").replace('\xa0', '')
+    y_col = ("Fit_Data_"+channel).replace('\xa0', '')
+
+    # fig.add_trace(go.Scatter(
+    #     x=plotly_data[x_col],
+    #     y=plotly_data[y_col],
+    #     mode='markers',
+    #     name=x_col.replace('_Spends', '')
+    # ))
+
+    fig.add_trace(go.Scatter(
+        x=plotly_data.sort_values(by=x_col, ascending=True)[x_col],
+        y=plotly_data.sort_values(by=x_col, ascending=True)[y_col],
+        mode='lines+markers',
+        name=x_col.replace('_Spends', '')
+    ))
+    
+    plotly_data2 = plotly_data.copy()
+    # .dropna(subset=[x_col]).reset_index(inplace = True)
+    fig.add_trace(go.Scatter(
+        x=plotly_data[plotly_data2['Date'] == plotly_data2['Date'].max()][x_col],
+        y=plotly_data[plotly_data2['Date'] == plotly_data2['Date'].max()][y_col],
+        mode='markers',
+        marker=dict(
+        size=13  # Adjust the size value to make the markers larger or smaller
+        , color = 'green'
+        ),
+        name="Current Spends"
+    ))
+
+    fig.add_trace(go.Scatter(
+        x=[x_modified],
+        y=[y_modified],
+        mode='markers',
+        marker=dict(
+        size=13  # Adjust the size value to make the markers larger or smaller
+        , color = 'blue'
+        ),
+        name="Optimised Spends"
+    ))
+
+    # Update layout with titles
+    fig.update_layout(
+        title=channel+' Response Curve',
+        xaxis_title='Weekly Spends',
+        yaxis_title='Prospects'
+    )
+
+    # Show the figure
+    return fig
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.optimize import curve_fit
+from sklearn.preprocessing import MinMaxScaler
+import warnings
+warnings.filterwarnings("ignore")
+import plotly.graph_objects as go
+
+## reading input data
+df= pd.read_csv('response_curves_input_file.csv')
+df.dropna(inplace=True)
+df['Date'] = pd.to_datetime(df['Date'])
+df.reset_index(inplace=True)
+
+channel_cols = [
+    'BroadcastTV',
+    'CableTV',
+    'Connected&OTTTV',
+    'DisplayProspecting',
+    'DisplayRetargeting',
+        'Video',
+    'SocialProspecting',
+    'SocialRetargeting',
+    'SearchBrand',
+    'SearchNon-brand',
+    'DigitalPartners',
+    'Audio',
+    'Email']
+spend_cols = [
+'tv_broadcast_spend', 
+'tv_cable_spend',
+    'stream_video_spend', 
+    'disp_prospect_spend', 
+    'disp_retarget_spend',
+       'olv_spend', 
+        'social_prospect_spend', 
+        'social_retarget_spend',
+       'search_brand_spend', 
+    'search_nonbrand_spend', 
+    'cm_spend',
+       'audio_spend',
+        'email_spend']
+prospect_cols = [
+        'Broadcast TV_Prospects',
+       'Cable TV_Prospects', 
+    'Connected & OTT TV_Prospects', 
+       'Display Prospecting_Prospects', 
+    'Display Retargeting_Prospects',
+    'Video_Prospects',
+       'Social Prospecting_Prospects', 
+    'Social Retargeting_Prospects',
+       'Search Brand_Prospects', 
+    'Search Non-brand_Prospects',
+       'Digital Partners_Prospects',
+    'Audio_Prospects', 
+    'Email_Prospects']
+
+def hill_equation(x, Kd, n):
+    return x**n / (Kd**n + x**n)
+
+
+def hill_func(x_data,y_data,x_minmax,y_minmax):
+    # Fit the Hill equation to the data
+    initial_guess = [1, 1]  # Initial guess for Kd and n
+    params, covariance = curve_fit(hill_equation, x_data, y_data, p0=initial_guess,maxfev = 1000)
+
+    # Extract the fitted parameters
+    Kd_fit, n_fit = params
+    
+
+    # Generate y values using the fitted parameters
+    y_fit = hill_equation(x_data, Kd_fit, n_fit)
+
+    x_data_inv = x_minmax.inverse_transform(np.array(x_data).reshape(-1,1))
+    y_data_inv = y_minmax.inverse_transform(np.array(y_data).reshape(-1,1))
+    y_fit_inv = y_minmax.inverse_transform(np.array(y_fit).reshape(-1,1))
+
+#     # Plot the original data and the fitted curve
+#     plt.scatter(x_data_inv, y_data_inv, label='Actual Data')
+#     plt.scatter(x_data_inv, y_fit_inv, label='Fit Data',color='red')
+#     # plt.line(x_data_inv, y_fit_inv, label=f'Fitted Hill Equation (Kd={Kd_fit:.2f}, n={n_fit:.2f})', color='red')
+#     plt.xlabel('Ligand Concentration')
+#     plt.ylabel('Fraction of Binding')
+#     plt.title('Fitting Hill Equation to Data')
+#     plt.legend()
+#     plt.show()
+
+    return y_fit,y_fit_inv,Kd_fit, n_fit
+
+def data_output(channel,X,y,y_fit_inv,x_ext_data,y_fit_inv_ext): 
+    fit_col = 'Fit_Data_'+channel
+    plot_df = pd.DataFrame()
+   
+    plot_df[f'{channel}_Spends'] = X
+
+    plot_df['Date'] = df['Date']
+    plot_df['MAT'] = df['MAT']
+    
+    
+
+    y_fit_inv_v2 = []
+    for i in range(len(y_fit_inv)):
+        y_fit_inv_v2.append(y_fit_inv[i][0])
+        
+    plot_df[fit_col] = y_fit_inv_v2
+    
+#     adding extra data
+
+    y_fit_inv_v2_ext = []
+    for i in range(len(y_fit_inv_ext)):
+        y_fit_inv_v2_ext.append(y_fit_inv_ext[i][0])
+    
+#     print(x_ext_data)
+    ext_df = pd.DataFrame()
+    ext_df[f'{channel}_Spends'] = x_ext_data
+    ext_df[fit_col] = y_fit_inv_v2_ext
+    
+    ext_df['Date'] =  [
+                    np.datetime64('1950-01-01'),
+                    np.datetime64('1950-06-15'),
+                    np.datetime64('1950-12-31')
+                ]
+
+    ext_df['MAT'] = ["ext","ext","ext"]
+    
+    print(ext_df)
+    plot_df= plot_df.append(ext_df)
+    return plot_df
+
+def input_data(df,spend_col,prospect_col):  
+    X = np.array(df[spend_col].tolist())
+    y = np.array(df[prospect_col].tolist())
+
+    x_minmax = MinMaxScaler()
+    x_scaled = x_minmax.fit_transform(df[[spend_col]])
+    x_data = []
+    for i in range(len(x_scaled)):
+        x_data.append(x_scaled[i][0])
+
+    y_minmax = MinMaxScaler()
+    y_scaled =  y_minmax.fit_transform(df[[prospect_col]])
+    y_data = []
+    for i in range(len(y_scaled)):
+        y_data.append(y_scaled[i][0])
+
+    return X,y,x_data,y_data,x_minmax,y_minmax
+
+def extend_s_curve(x_max,x_minmax,y_minmax, Kd_fit, n_fit):
+    print(x_max)
+    x_ext_data = [x_max*1.2,x_max*1.3,x_max*1.5]
+#     x_ext_data = [1500000,2000000,2500000]
+#     x_ext_data = [x_max+100,x_max+200,x_max+5000]
+    x_scaled = x_minmax.transform(pd.DataFrame(x_ext_data))
+    x_data = []
+    for i in range(len(x_scaled)):
+        x_data.append(x_scaled[i][0])
+        
+    print(x_data)
+    y_fit = hill_equation(x_data, Kd_fit, n_fit)
+    y_fit_inv = y_minmax.inverse_transform(np.array(y_fit).reshape(-1,1))
+    
+    return x_ext_data,y_fit_inv
+    
+def fit_data(spend_col,prospect_col,channel):
+    ### getting k and n parameters
+    temp_df = df[df[spend_col]>0]
+    temp_df.reset_index(inplace=True)
+
+    X,y,x_data,y_data,x_minmax,y_minmax = input_data(temp_df,spend_col,prospect_col)
+    y_fit, y_fit_inv, Kd_fit, n_fit = hill_func(x_data,y_data,x_minmax,y_minmax)
+    print('k: ',Kd_fit)
+    print('n: ', n_fit)
+    
+    ##### extend_s_curve
+    x_ext_data,y_fit_inv_ext=  extend_s_curve(temp_df[spend_col].max(),x_minmax,y_minmax, Kd_fit, n_fit)
+    
+    plot_df = data_output(channel,X,y,y_fit_inv,x_ext_data,y_fit_inv_ext)
+    return plot_df
+
+plotly_data = fit_data(spend_cols[0],prospect_cols[0],channel_cols[0])
+plotly_data.tail()
+
+for i in range(1,13):
+    print(i)
+    pdf =  fit_data(spend_cols[i],prospect_cols[i],channel_cols[i])
+    plotly_data = plotly_data.merge(pdf,on = ["Date","MAT"],how = "left")
+    
+def response_curves(channel,x_modified,y_modified):
+
+    # Initialize the Plotly figure
+    fig = go.Figure()
+
+    x_col = (channel+"_Spends").replace('\xa0', '')
+    y_col = ("Fit_Data_"+channel).replace('\xa0', '')
+
+    # fig.add_trace(go.Scatter(
+    #     x=plotly_data[x_col],
+    #     y=plotly_data[y_col],
+    #     mode='markers',
+    #     name=x_col.replace('_Spends', '')
+    # ))
+
+    fig.add_trace(go.Scatter(
+        x=plotly_data.sort_values(by=x_col, ascending=True)[x_col],
+        y=plotly_data.sort_values(by=x_col, ascending=True)[y_col],
+        mode='lines',
+        marker=dict(color = 'blue'),
+        name=x_col.replace('_Spends', '')
+    ))
+    
+    plotly_data2 = plotly_data.copy()
+    # .dropna(subset=[x_col]).reset_index(inplace = True)
+    fig.add_trace(go.Scatter(
+        x=plotly_data[plotly_data2['Date'] == plotly_data2['Date'].max()][x_col],
+        y=plotly_data[plotly_data2['Date'] == plotly_data2['Date'].max()][y_col],
+        mode='markers',
+        marker=dict(
+        size=13  # Adjust the size value to make the markers larger or smaller
+        , color = '#516DA6'
+        ),
+        name="Current Spends"
+    ))
+
+    fig.add_trace(go.Scatter(
+        x=[x_modified],
+        y=[y_modified],
+        mode='markers',
+        marker=dict(
+        size=13  # Adjust the size value to make the markers larger or smaller
+        , color = '#4ACAD9'
+        ),
+        name="Optimised Spends"
+    ))
+
+    # Update layout with titles
+    fig.update_layout(
+        title=channel+' Response Curve',
+        xaxis_title='Weekly Spends',
+        yaxis_title='Prospects'
+    )
+
+    # Show the figure
+    return fig
+

response_curves_model_quality_base.py

@@ -0,0 +1,230 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.optimize import curve_fit
+from sklearn.preprocessing import MinMaxScaler
+import warnings
+warnings.filterwarnings("ignore")
+import plotly.graph_objects as go
+
+## reading input data
+df= pd.read_csv('response_curves_input_file.csv')
+df.dropna(inplace=True)
+df['Date'] = pd.to_datetime(df['Date'])
+df.reset_index(inplace=True)
+
+channel_cols = [
+ 'Broadcast TV',
+ 'Cable TV',
+ 'Connected & OTT TV',
+ 'Display Prospecting',
+ 'Display Retargeting',
+    'Video',
+ 'Social Prospecting',
+ 'Social Retargeting',
+ 'Search Brand',
+ 'Search Non-brand',
+ 'Digital Partners',
+ 'Audio',
+ 'Email']
+spend_cols = [
+'tv_broadcast_spend', 
+'tv_cable_spend',
+    'stream_video_spend', 
+    'disp_prospect_spend', 
+    'disp_retarget_spend',
+       'olv_spend', 
+        'social_prospect_spend', 
+        'social_retarget_spend',
+       'search_brand_spend', 
+    'search_nonbrand_spend', 
+    'cm_spend',
+       'audio_spend',
+        'email_spend']
+prospect_cols = [
+        'Broadcast TV_Prospects',
+       'Cable TV_Prospects', 
+    'Connected & OTT TV_Prospects', 
+       'Display Prospecting_Prospects', 
+    'Display Retargeting_Prospects',
+    'Video_Prospects',
+       'Social Prospecting_Prospects', 
+    'Social Retargeting_Prospects',
+       'Search Brand_Prospects', 
+    'Search Non-brand_Prospects',
+       'Digital Partners_Prospects',
+    'Audio_Prospects', 
+    'Email_Prospects']
+
+def hill_equation(x, Kd, n):
+    return x**n / (Kd**n + x**n)
+
+
+def hill_func(x_data,y_data,x_minmax,y_minmax):
+    # Fit the Hill equation to the data
+    initial_guess = [1, 1]  # Initial guess for Kd and n
+    params, covariance = curve_fit(hill_equation, x_data, y_data, p0=initial_guess,maxfev = 1000)
+
+    # Extract the fitted parameters
+    Kd_fit, n_fit = params
+    
+
+    # Generate y values using the fitted parameters
+    y_fit = hill_equation(x_data, Kd_fit, n_fit)
+
+    x_data_inv = x_minmax.inverse_transform(np.array(x_data).reshape(-1,1))
+    y_data_inv = y_minmax.inverse_transform(np.array(y_data).reshape(-1,1))
+    y_fit_inv = y_minmax.inverse_transform(np.array(y_fit).reshape(-1,1))
+
+#     # Plot the original data and the fitted curve
+#     plt.scatter(x_data_inv, y_data_inv, label='Actual Data')
+#     plt.scatter(x_data_inv, y_fit_inv, label='Fit Data',color='red')
+#     # plt.line(x_data_inv, y_fit_inv, label=f'Fitted Hill Equation (Kd={Kd_fit:.2f}, n={n_fit:.2f})', color='red')
+#     plt.xlabel('Ligand Concentration')
+#     plt.ylabel('Fraction of Binding')
+#     plt.title('Fitting Hill Equation to Data')
+#     plt.legend()
+#     plt.show()
+
+    return y_fit,y_fit_inv,Kd_fit, n_fit
+
+def data_output(channel,X,y,y_fit_inv,x_ext_data,y_fit_inv_ext): 
+    fit_col = 'Fit_Data_'+channel
+    plot_df = pd.DataFrame()
+   
+    plot_df[f'{channel}_Spends'] = X
+
+    plot_df['Date'] = df['Date']
+    plot_df['MAT'] = df['MAT']
+    
+    
+
+    y_fit_inv_v2 = []
+    for i in range(len(y_fit_inv)):
+        y_fit_inv_v2.append(y_fit_inv[i][0])
+        
+    plot_df[fit_col] = y_fit_inv_v2
+    
+#     adding extra data
+
+    y_fit_inv_v2_ext = []
+    for i in range(len(y_fit_inv_ext)):
+        y_fit_inv_v2_ext.append(y_fit_inv_ext[i][0])
+    
+#     print(x_ext_data)
+    ext_df = pd.DataFrame()
+    ext_df[f'{channel}_Spends'] = x_ext_data
+    ext_df[fit_col] = y_fit_inv_v2_ext
+    
+    ext_df['Date'] =  [
+                    np.datetime64('1950-01-01'),
+                    np.datetime64('1950-06-15'),
+                    np.datetime64('1950-12-31')
+                ]
+
+    ext_df['MAT'] = ["ext","ext","ext"]
+    
+    print(ext_df)
+    plot_df= plot_df.append(ext_df)
+    return plot_df
+
+def input_data(df,spend_col,prospect_col):  
+    X = np.array(df[spend_col].tolist())
+    y = np.array(df[prospect_col].tolist())
+
+    x_minmax = MinMaxScaler()
+    x_scaled = x_minmax.fit_transform(df[[spend_col]])
+    x_data = []
+    for i in range(len(x_scaled)):
+        x_data.append(x_scaled[i][0])
+
+    y_minmax = MinMaxScaler()
+    y_scaled =  y_minmax.fit_transform(df[[prospect_col]])
+    y_data = []
+    for i in range(len(y_scaled)):
+        y_data.append(y_scaled[i][0])
+
+    return X,y,x_data,y_data,x_minmax,y_minmax
+
+def extend_s_curve(x_max,x_minmax,y_minmax, Kd_fit, n_fit):
+    print(x_max)
+    x_ext_data = [x_max*1.2,x_max*1.3,x_max*1.5]
+#     x_ext_data = [1500000,2000000,2500000]
+#     x_ext_data = [x_max+100,x_max+200,x_max+5000]
+    x_scaled = x_minmax.transform(pd.DataFrame(x_ext_data))
+    x_data = []
+    for i in range(len(x_scaled)):
+        x_data.append(x_scaled[i][0])
+        
+    print(x_data)
+    y_fit = hill_equation(x_data, Kd_fit, n_fit)
+    y_fit_inv = y_minmax.inverse_transform(np.array(y_fit).reshape(-1,1))
+    
+    return x_ext_data,y_fit_inv
+    
+def fit_data(spend_col,prospect_col,channel):
+    ### getting k and n parameters
+    temp_df = df[df[spend_col]>0]
+    temp_df.reset_index(inplace=True)
+
+    X,y,x_data,y_data,x_minmax,y_minmax = input_data(temp_df,spend_col,prospect_col)
+    y_fit, y_fit_inv, Kd_fit, n_fit = hill_func(x_data,y_data,x_minmax,y_minmax)
+    print('k: ',Kd_fit)
+    print('n: ', n_fit)
+    
+    ##### extend_s_curve
+    x_ext_data,y_fit_inv_ext=  extend_s_curve(temp_df[spend_col].max(),x_minmax,y_minmax, Kd_fit, n_fit)
+    
+    plot_df = data_output(channel,X,y,y_fit_inv,x_ext_data,y_fit_inv_ext)
+    return plot_df
+
+plotly_data = fit_data(spend_cols[0],prospect_cols[0],channel_cols[0])
+plotly_data.tail()
+
+for i in range(1,13):
+    print(i)
+    pdf =  fit_data(spend_cols[i],prospect_cols[i],channel_cols[i])
+    plotly_data = plotly_data.merge(pdf,on = ["Date","MAT"],how = "left")
+    
+def response_curves(channel,chart_typ):
+    if chart_typ == 'View Scattered Plot':
+        mode_f1 = "markers"
+    elif chart_typ == 'View Line Plot':
+        mode_f1 = "lines"
+    else:
+        mode_f1 = "lines+markers"
+
+
+    # Initialize the Plotly figure
+    fig = go.Figure()
+
+    x_col = channel+"_Spends"
+    y_col = "Fit_Data_"+channel
+    fig.add_trace(go.Scatter(
+        x=plotly_data.sort_values(by=x_col, ascending=True)[x_col],
+        y=plotly_data.sort_values(by=x_col, ascending=True)[y_col],
+        mode=mode_f1,
+        name=x_col.replace('_Spends', '')
+    ))
+
+    fig.add_trace(go.Scatter(
+        x=plotly_data[plotly_data['Date'] == plotly_data['Date'].max()][x_col],
+        y=plotly_data[plotly_data['Date'] == plotly_data['Date'].max()][y_col],
+        mode='markers',
+        marker=dict(
+        size=13  # Adjust the size value to make the markers larger or smaller
+        , color = 'green'
+        ),
+        name="Current Spends"
+    ))
+
+    # Update layout with titles
+    fig.update_layout(
+        title=channel+' Response Curve',
+        xaxis_title='Weekly Spends',
+        yaxis_title='Prospects'
+    )
+
+    # Show the figure
+    return fig
+

summary_df.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:41027251e75b11465e5cec329b14a8e35d4791aa6fdbbc948a0f32b4c1acc286
-size 1886
+oid sha256:6e33a4c4ff46b7f8107d89facbd624828fae4b25965ede19b314805579134823
+size 1822