version changes

Model_Result_Overview.py

@@ -112,7 +112,7 @@ if auth_status:
     
     # Create two columns for start date and end date input
     col1, col2 = st.columns(2)
-        
+                                                                
     with col1:
         default_date = datetime(2024, 1, 28)
         start_date = st.date_input("Start Date: ",value=default_date)
@@ -121,6 +121,17 @@ if auth_status:
         default_date = datetime(2024, 2, 24)
         end_date = st.date_input("End Date: ",value=default_date)
     
+    # col1, col2 = st.columns(2)
+    # with col1:
+    #     fig = sf.pie_spend(start_date,end_date)
+    #     st.plotly_chart(fig,use_container_width=True)
+    # with col2:
+    #     fig = sf.pie_contributions(start_date,end_date)
+    #     st.plotly_chart(fig,use_container_width=True)
+    # st.header("Distribution of Spends and Contributions")
+    fig = sf.pie_charts(start_date,end_date)
+    st.plotly_chart(fig,use_container_width=True)
+
     # Dropdown menu options
     options = [
         "Month on Month",
@@ -128,7 +139,7 @@ if auth_status:
     col1, col2 = st.columns(2)
          # Create a dropdown menu
     with col1:
-        selected_option = st.selectbox('Select a comparision', options)
+        selected_option = st.selectbox('Select a comparison', options)
     with col2:
         st.write("")
         # Waterfall chart
@@ -162,10 +173,10 @@ if auth_status:
 
         ### 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)
+     
+    
+    # st.write(fig.columns)
+    # st.dataframe(fig)
 
     # def panel_fetch(file_selected):
     #     raw_data_mmm_df = pd.read_excel(file_selected, sheet_name="RAW DATA MMM")
@@ -282,7 +293,7 @@ if auth_status:
 # col1, col2 = st.columns(2)
 #      # Create a dropdown menu
 # with col1:
-#     selected_option = st.selectbox('Select a comparision', options)
+#     selected_option = st.selectbox('Select a comparison', options)
 # with col2:
 #     st.write("")
 #     # Waterfall chart

Streamlit_functions.py

@@ -12,8 +12,7 @@ from datetime import datetime,timedelta
 from plotly.subplots import make_subplots
 import pandas as pd
 import json
-
-
+from numerize.numerize import numerize 
 
 # working_directory = r"C:\Users\PragyaJatav\Downloads\Deliverables\Deliverables\Response Curves 09_07_24\Response Curves Resources"
 # os.chdir(working_directory)
@@ -80,19 +79,62 @@ contribution_cols = [
  'Audio_Prospects',
  'Email_Prospects']
 
-def pie1(start_date,end_date):
+def pie_charts(start_date,end_date):
+    start_date = pd.to_datetime(start_date)
+    end_date = pd.to_datetime(end_date)
+    import plotly.graph_objects as go
+    from plotly.subplots import make_subplots
+    cur_data = df[(df['Date'] >= start_date) & (df['Date'] <= end_date)]
+    data1 = pd.DataFrame(cur_data[spend_cols].sum().transpose())
+    data2 = pd.DataFrame(cur_data[contribution_cols].sum().transpose())
+
+    data1.index = channels
+    data1.columns = ["p"]
+    
+    data2.index = channels
+    data2.columns = ["p"]
+
+    fig = make_subplots(rows=1, cols=2, specs=[[{'type':'domain'}, {'type':'domain'}]])
+
+    fig.add_trace(go.Pie(labels=channels, 
+                         values=data1["p"], 
+                         name="t2",
+                         hoverinfo='label+percent',
+                        textinfo= 'label+percent',
+                        showlegend= False,textfont=dict(size =10),
+                        # title="Distribution of Spends"
+                        ), 1, 1)
+
+    fig.add_trace(go.Pie(labels=channels, 
+                         values=data2["p"], 
+                         name="t2",
+                         hoverinfo='label+percent',
+                        textinfo= 'label+percent',
+                        showlegend= False,
+                        textfont=dict(size = 10),
+                        # title = "Distribution of Contributions"
+                        ), 1, 2)
+    fig.update_layout(
+        title="Distribution of Spends and Contributions"
+    )
+
+    return fig
+
+def pie_spend(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 = pd.DataFrame(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"],
+        values=data["p"],#ype(str)+'<br>'+data.index,
         hoverinfo='label+percent',
-        # textinfo='value',
+        textinfo= 'label+percent',
+        showlegend= False,
+        textfont=dict(size = 10)
         
     )])
 
@@ -102,7 +144,36 @@ def pie1(start_date,end_date):
     )
 
     # Show the figure
-    return data
+    return fig
+def pie_contributions(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 = pd.DataFrame(cur_data[contribution_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"],#ype(str)+'<br>'+data.index,
+        hoverinfo='label+percent',
+        textinfo= 'label+percent',
+        textposition='auto',
+        showlegend= False,
+        textfont=dict(size = 10)
+        
+    )])
+
+    # fig.add_annotation(showarrow=False)
+    # Customize the layout
+    fig.update_layout(
+        title="Distribution of Contributions",
+        # margin=dict(t=0, b=0, l=0, r=0)
+    )
+    
+
+    # Show the figure
+    return fig
 
 def waterfall(start_date,end_date,btn_chart):
     # if pd.isnull(start_date) == True :
@@ -762,3 +833,58 @@ def model_metrics_table_func():
     return model_metrics_df.round(2)
 
 
+def scenario_spend_forecasting(delta_df,start_date,end_date):
+    
+    key_df = pd.DataFrame()
+    key_df["Channel_name"] = ["Email",
+                              "DisplayRetargeting",
+                          "\xa0Video",
+                          "BroadcastTV",
+                          "SocialRetargeting",
+                          "Connected&OTTTV",
+                          "SearchBrand",
+                          "Audio",
+                          "SocialProspecting",
+                          "CableTV",
+                          "DisplayProspecting",
+                          "SearchNon-brand",
+                          "DigitalPartners"]
+    key_df["Channels"] = [
+    "EMAIL",
+    "DISPLAY RETARGETING",
+    "VIDEO",
+    "BROADCAST TV",
+    "SOCIAL RETARGETING",
+    "CONNECTED & OTT TV",
+    "SEARCH BRAND",
+    "AUDIO",
+    "SOCIAL PROSPECTING",
+    "CABLE TV",
+    "DISPLAY PROSPECTING",
+    "SEARCH NON-BRAND",
+    "DIGITAL PARTNERS"
+]
+
+        
+    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)]
+    cur_data = cur_data[spend_cols]
+    cur_data.columns = channels
+    data1 = pd.DataFrame(cur_data[channels].sum().transpose()).reset_index()
+    data1.columns = ["Channels","last_year_spends"]
+
+    df_modified = delta_df.merge(key_df,on = "Channel_name",how = "inner")
+    df_modified2 = df_modified.merge(data1,on = "Channels",how ="outer")
+    df_modified2["Forecasted Spends"] =( df_modified2["last_year_spends"]*(1+df_modified2["Delta_percent"]/100)).apply(numerize)
+    df_modified2.index = df_modified2["Channels"]
+    df_modified2["Spend Change"] = df_modified2["Delta_percent"]
+    df_modified2["Last Year Spends"] = df_modified2["last_year_spends"].apply(numerize)
+    df_modified3 = df_modified2[["Last Year Spends","Forecasted Spends","Spend Change"]].transpose()
+    # df_modified2["forecasted_spends"] = 
+    # # df_modified = delta_percent
+    # # df_modified["Optimised Spends"] = df_modified["Current Spends"]*
+    return df_modified3
+
+

classes.py

@@ -58,7 +58,7 @@ class Channel:
         spends,
         response_curve_type,
         response_curve_params,
-        bounds,
+        bounds,channel_bounds_min,channel_bounds_max,
         conversion_rate=1,
         modified_spends=None,
         penalty=True,
@@ -76,6 +76,8 @@ class Channel:
         self.response_curve_type = response_curve_type
         self.response_curve_params = response_curve_params
         self.bounds = bounds
+        self.channel_bounds_min = channel_bounds_min
+        self.channel_bounds_max = channel_bounds_max
         self.penalty = penalty
 
         self.upper_limit = self.actual_spends.max() + self.actual_spends.std()
@@ -160,6 +162,12 @@ class Channel:
         self.modified_total_sales = self.modified_sales.sum()
         self.delta_spends = self.modified_total_spends - self.actual_total_spends
         self.delta_sales = self.modified_total_sales - self.actual_total_sales
+    
+    def update_bounds_min(self, modified_bound):
+        self.channel_bounds_min = modified_bound
+    
+    def update_bounds_max(self, modified_bound):
+        self.channel_bounds_max = modified_bound
 
     def intialize(self):
         self.new_spends = self.old_spends
@@ -237,6 +245,14 @@ class Scenario:
         self.delta_spends = self.modified_total_spends - self.actual_total_spends
         self.delta_sales = self.modified_total_sales - self.actual_total_sales
 
+    def update_bounds_min(self, channel_name,modified_bound):
+        # self.modify_spends(total_spends)
+        self.channels[channel_name].update_bounds_min(modified_bound)
+
+    def update_bounds_max(self, channel_name,modified_bound):
+        # self.modify_spends(total_spends)
+        self.channels[channel_name].update_bounds_max(modified_bound)
+
     # def optimize_spends(self, sales_percent, channels_list, algo="COBYLA"):
     #     desired_sales = self.actual_total_sales * (1 + sales_percent / 100.0)
 

pages/2_Scenario_Planner.py

@@ -5,6 +5,10 @@ from functools import partial
 from collections import OrderedDict
 from plotly.subplots import make_subplots
 import plotly.graph_objects as go
+from datetime import datetime, timedelta
+from dateutil.relativedelta import relativedelta
+import time
+import Streamlit_functions as sf
 from utilities import (
     format_numbers,format_numbers_f,
     load_local_css,
@@ -263,7 +267,28 @@ def validate_input(string_input):
         return False
     return True
 
-
+def update_data_bound_min(channel_name):
+    """
+    Updates the bounds for the given channel
+    """
+    modified_bounds = st.session_state[f"{channel_name}_lower_bound"]
+    
+    # st.session_state['scenario']['channels'][channel_name].channel_bounds_min = st.session_state[f"{channel_name}_lower_bound"]
+    st.session_state['scenario'].update_bounds_min(channel_name,modified_bounds)
+    st.write(st.session_state["scenario"].channels[channel_name].channel_bounds_min)
+    # st.write(st.session_state["scenario"].channels[channel_name])
+    
+def update_data_bound_max(channel_name):
+    """
+    Updates the bounds for the given channel
+    """
+    modified_bounds = st.session_state[f"{channel_name}_upper_bound"]
+    
+    # st.session_state['scenario']['channels'][channel_name].channel_bounds_min = st.session_state[f"{channel_name}_lower_bound"]
+    st.session_state['scenario'].update_bounds_max(channel_name,modified_bounds)
+    # st.write(st.session_state["scenario"].channels[channel_name].channel_bounds_max)
+    # st.write(st.session_state["scenario"].channels[channel_name])
+    
 def update_data_by_percent(channel_name):
     prev_spends = (
         st.session_state["scenario"].channels[channel_name].actual_total_spends
@@ -299,6 +324,7 @@ def update_data(channel_name):
             modified_spends
             / st.session_state["scenario"].channels[channel_name].conversion_rate,
         )
+# st.write(hasattr(st.session_state["scenario"], 'update_bounds_min'))
     # st.session_state['scenario'].update(channel_name, modified_spends)
     # else:
     #     try:
@@ -311,6 +337,8 @@ def update_data(channel_name):
     #         st.write('Invalid input')
 
 
+
+
 def select_channel_for_optimization(channel_name):
     """
     Marks the given channel for optimization
@@ -519,6 +547,8 @@ def plot_response_curves(summary_df_sorted):
     '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)]
+
+    # for i in range()
     
     # Display figures in a grid layout
     cols = st.columns(3)  # 4 columns for the grid
@@ -739,59 +769,52 @@ def reset_inputs():
         del st.session_state.total_sales_change_abs_slider
 
     st.session_state["initialized"] = False
+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
 
-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
 
-            # 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')
 
-            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)
+        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())
 
-            # 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()
+        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']
 
-            actual_spend_percentage = (summary_df_sorted['Actual_spend'] / total_actual_spend) * 100
-            optimized_spend_percentage = (summary_df_sorted['Optimized_spend'] / total_optimized_spend) * 100
+        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)'
 
+        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
+        # # 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',
@@ -841,11 +864,11 @@ if auth_status == True:
             # 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 = 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',
+        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) + ' '
                                 #  + 
                                 #  ' '+
@@ -854,62 +877,67 @@ if auth_status == True:
                                 marker_color=light_blue))
             
             
-            fig.add_trace(go.Bar(x=summary_df_sorted['Channel_name'], y=summary_df_sorted['Optimized_spend'], name='Optimized',
+        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",
+        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)
+        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'], 
+        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'],
+        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",
+        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)
+        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'], 
+        # 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'], 
+        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="Efficiency")
-            fig.update_layout(
+        fig.update_xaxes(title_text="Channels")
+        fig.update_yaxes(title_text="Efficiency")
+        fig.update_layout(
                 title = "Actual vs. Optimized Efficiency",
                         margin=dict(t=40, b=40, l=40, r=40),
                         # yaxis=dict(range=[0, 0.002]),
                     )
                 
-            st.plotly_chart(fig,use_container_width=True)
+        st.plotly_chart(fig,use_container_width=True)
+
+if auth_status == True:
+    authenticator.logout("Logout", "main")
+    st.header("Scenario Planner")
+    
 
 
     # Response Metrics
@@ -1023,39 +1051,119 @@ if auth_status == True:
         st.session_state.total_sales_change_abs_slider = numerize(
             _scenario.actual_total_sales, 1
         )
+    
+    if "lower_bound_key" not in st.session_state:
+        st.session_state["lower_bound_key"] = 10
+    
+    if "upper_bound_key" not in st.session_state:
+        st.session_state["upper_bound_key"] = 10
 
-    with main_header[0]:
-        st.subheader("Actual")
+    
+    header_df = pd.DataFrame(index=["Actual","Simulated","Change","Percent Change"],columns=["Spends","Prospects"])
+    header_df["Spends"]["Actual"] = format_numbers(_scenario.actual_total_spends)
+    header_df["Spends"]["Simulated"] = format_numbers(_scenario.modified_total_spends)
+    header_df["Spends"]["Change"] = format_numbers(_scenario.delta_spends) #_scenario.modified_total_spends -_scenario.actual_total_spends
+    header_df["Spends"]["Percent Change"] = numerize(100*(_scenario.delta_spends/_scenario.actual_total_spends))+'%'
+    
+    header_df["Prospects"]["Actual"] = format_numbers_f(float(_scenario.actual_total_sales))
+    header_df["Prospects"]["Simulated"] = format_numbers_f(float(_scenario.modified_total_sales))
+    header_df["Prospects"]["Change"] = format_numbers_f(_scenario.delta_sales)
+    header_df["Prospects"]["Percent Change"] = numerize(100*(_scenario.delta_sales/_scenario.actual_total_sales),1)+'%'
+   
+    # header_df.reset_index(inplace=True)
+    # # Function to color the index
+    # def highlight_index(s):
+    #     return ['background-color: lightblue' for _ in s]
+
+    # # Function to color the header
+    # def highlight_header(s):
+    #     return ['background-color: lightgreen' for _ in s]
+
+    # # Applying the styles
+    # styled_df = header_df.style \
+    #     .apply(highlight_index, axis=0, subset=pd.IndexSlice[:, :]) \
+    #     .set_table_styles({
+    #         'A': [{'selector': 'th', 'props': [('background-color', 'lightgreen')]}],
+    #         'B': [{'selector': 'th', 'props': [('background-color', 'lightgreen')]}],
+    #         'C': [{'selector': 'th', 'props': [('background-color', 'lightgreen')]}]
+    #     })
+
+    # # Function to apply arrows based on value
+    # def format_arrows(val):
+    #     if val > 0:
+    #         return '<span style="color: green;">&#9650;</span>'  # Green up arrow
+    #     elif val < 0:
+    #         return '<span style="color: red;">&#9660;</span>'  # Red down arrow
+    #     return ''  # No arrow for zero
+
+    # # Function to format specific rows and exclude the first column
+    # def apply_row_formatting(df, rows):
+    #     def format_cell(val, row_idx, col_idx):
+    #         if row_idx in rows and col_idx > 0:  # Exclude the first column (col_idx > 0)
+    #             return format_arrows(val)
+    #         return ''  # No formatting for other cells
+        
+    #     return df.style.apply(lambda x: [format_cell(val, i, col) for i, (val, col) in enumerate(zip(x, range(len(x))))], axis=1)
 
-    with main_header[-1]:
-        st.subheader("Simulated")
+    # # Apply formatting to 3rd and 4th rows (index 2 and 3)
+    # styled_df = apply_row_formatting(header_df, [2, 3])
 
-    with sub_header[0]:
-        st.metric(label="Spends", value=format_numbers(_scenario.actual_total_spends))
+    # st.markdown(styled_df.to_html(escape=False), unsafe_allow_html=True)
+    
+    st.markdown(header_df.style.set_table_styles
+                ([{'selector': 'th',
+                    'props': [('background-color', '#D3D3D3'),
+         ('font-size', '25px')]},
+                {
+                    'selector' : 'td:first-child',
+                    'props' : [('background-color', '#D3D3D3'),
+         ('font-size', '25px')]
+                }
+                ,
+                {'selector': 'tbody td',
+     'props': [('font-size', '20px')]} 
+
+                ]).to_html(),unsafe_allow_html=True)   
+                    
 
-    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),
-        )
+  # styled_df = header_df.style.apply(highlight_first_col, axis=1) 
 
-    with sub_header[3]:
-        st.metric(
-            label=target,
-            value=format_numbers_f(
-                float(_scenario.modified_total_sales)
-            ),
-            delta=numerize(_scenario.delta_sales, 1),
-        )
+    # st.table(styled_df)
+
+
+    # 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))
@@ -1159,8 +1267,8 @@ if auth_status == True:
             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)
+                # 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"] = [
@@ -1202,7 +1310,7 @@ if auth_status == True:
         )
 
         st.markdown("""<hr class="spends-heading-seperator">""", unsafe_allow_html=True)
-        _columns = st.columns((2.5, 2, 1.5, 1.5, 1))
+        _columns = st.columns((2, 2.5, 1.5, 1.5, 0.5))
         with _columns[0]:
             generate_spending_header("Channel")
         with _columns[1]:
@@ -1228,34 +1336,60 @@ if auth_status == True:
         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))
+            # st.write(st.session_state["scenario"].channels[channel_name])
+            # st.write(st.session_state["scenario"].channels[channel_name].actual_total_sales)
+            # st.write(st.session_state["scenario"].channels[channel_name].actual_total_spends)
+            # st.write(st.session_state["scenario"].channels[channel_name].modified_total_sales)
+            # st.write(st.session_state["scenario"].channels[channel_name].modified_total_spends)
+            # st.write(st.session_state["scenario"].channels[channel_name].bounds)
+            # st.write(st.session_state["scenario"].channels[channel_name].channel_bounds_min)
+            _columns = st.columns((2, 2.5, 1.5, 1.5, 0.5))
             with _columns[0]:
                 st.write(channel_name_formating(channel_name))
                 bin_placeholder = st.container()
 
             with _columns[1]:
                 channel_bounds = _channel_class.bounds
+                # st.write(channel_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)
+                channel_bounds_min = float(_channel_class.channel_bounds_min)
+                channel_bounds_max = float(_channel_class.channel_bounds_max)
+                min_value = float((1 - channel_bounds_min / 100) * channel_spends)
+                max_value = float((1 + channel_bounds_max / 100) * channel_spends)
+                # st.write(min_value)
+                # st.write(max_value)
                 ##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")
+                _columns_min = st.columns(2)
+                with _columns_min[0]:
+                    spend_input = st.text_input(
+                        "Absolute",
+                        key=channel_name,
+                        # label_visibility="collapsed",
+                        on_change=partial(update_data, channel_name),
+                    )
+                    channel_name_lower_bound = f"{channel_name}_lower_bound"
+                    channel_bounds_min = st.text_input(
+                        "Lower Bound Percentage",
+                        key = channel_name_lower_bound,
+                        on_change=partial(update_data_bound_min,channel_name),value=10
+                    )
+                    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_min[1]:
+                    st.number_input(
+                        "Percent Change",
+                        key=channel_name_current,
+                        step=1,
+                        on_change=partial(update_data_by_percent, channel_name),
+                    )
+                    channel_name_upper_bound = f"{channel_name}_upper_bound"
+                    channel_bounds_max = st.text_input(
+                        "Upper Bound Percentage",
+                        key = channel_name_upper_bound,
+                        on_change=partial(update_data_bound_max,channel_name),value=10
+                    )
 
             with _columns[2]:
                 # spends
@@ -1474,6 +1608,8 @@ if auth_status == True:
         2,
     )
 
+
+
     
 
     
@@ -1494,6 +1630,99 @@ if auth_status == True:
 
     scenario_planner_plots()
 
+    with st.expander ("View Forecasted spends"):
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            default_date = datetime(2024, 1, 28)
+            start_date1 = st.date_input("Select Start Date: ",value=default_date) -  relativedelta(years=1)
+        
+        with col2:
+            default_date = datetime(2024, 2, 24)
+            end_date1 = st.date_input("Select End Date: ",value=default_date)-  relativedelta(years=1)
+
+        with col3:
+            current_date = datetime(2024, 2, 24)
+            c1, c2, c3 = st.columns(3)
+            with c1:
+                if st.button('Next Month'):
+                    start_date1  = current_date-  relativedelta(years=1)
+                    end_date1 = current_date + relativedelta(months=1)-  relativedelta(years=1)
+            with c2:
+                if st.button('Next Quarter'):
+                    start_date1  = current_date-  relativedelta(years=1)
+                    end_date1 = current_date + relativedelta(months = 3)-  relativedelta(years=1)
+            with c3:
+                if st.button('Next Year'):
+                    start_date1  = current_date-  relativedelta(years=1)
+                    end_date1 = current_date + relativedelta(months = 12)-  relativedelta(years=1)
+
+        forecasted_table_df = sf.scenario_spend_forecasting(summary_df_sorted,start_date1,end_date1)
+        st.table(forecasted_table_df)
+        
+        st.markdown("""
+            <style>
+            .yellow-container {
+                background-color: #FFFF99;
+                border: 1px solid #FFD700;
+                padding: 10px;
+                border-radius: 5px;
+                margin-bottom: 10px;
+            }
+            </style>
+            """, unsafe_allow_html=True)
+        
+        def save_report_forecast(forecasted_table_df):
+            from io import BytesIO
+            # excel_file_path = filename+ '.xlsx'
+            # forecasted_table_df.to_excel(excel_file_path, index=False)
+
+            # Convert the DataFrame to an Excel file in memory
+            excel_file = BytesIO()
+            with pd.ExcelWriter(excel_file, engine='openpyxl') as writer:
+                forecasted_table_df.to_excel(writer, index=False, sheet_name='Sheet1')
+
+            # Seek to the beginning of the BytesIO buffer
+            excel_file.seek(0)
+            return excel_file
+            # message_container = st.empty()
+            # with message_container:
+            #     st.write(f'<div class="yellow-container">{"Report Saved!"}</div>', unsafe_allow_html=True)
+            #     time.sleep(5)
+            #     st.empty()
+
+        st.subheader("Download Report")
+        report_name = st.text_input(
+            "Report name",
+            key="report_input",
+            placeholder="Report name",
+            label_visibility="collapsed",
+        )
+
+
+        st.download_button(
+            "Download Report",
+            data = save_report_forecast(forecasted_table_df),
+            file_name = report_name+".xlsx",
+            mime="application/vnd.ms-excel",
+            # on_click=lambda: save_report_forecast(forecasted_table_df,report_name),
+            disabled=len(st.session_state["report_input"]) == 0,#use_container_width=True
+            )
+
+        # filename = st.text_input("Save Report: ",placeholder="Report name")
+        # if st.button("Download Report",disabled= (filename != "Report name")):
+        #     excel_file_path = filename+ '.xlsx'
+        #     forecasted_table_df.to_excel(excel_file_path, index=False)
+        #     message_container = st.empty()
+
+
+        #     with message_container:
+        #         st.write(f'<div class="yellow-container">{"Report Saved!"}</div>', unsafe_allow_html=True)
+        #         time.sleep(0.5)
+        #         st.empty()
+            
+        # on_click=lambda: save_scenario(scenario_name),
+        # disabled=len(st.session_state["scenario_input"]) == 0,#use_container_width=True
+         
     _columns = st.columns(2)
     # with _columns[0]:
     st.subheader("Save Scenario")
@@ -1507,7 +1736,9 @@ if auth_status == True:
         "Save",
         on_click=lambda: save_scenario(scenario_name),
         disabled=len(st.session_state["scenario_input"]) == 0,#use_container_width=True
+        
     )
+    
 
 
 

pages/3_Saved_Scenarios.py

@@ -23,7 +23,7 @@ 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():
+def comparison_scenarios_df():
     
     ## create summary page
     if len(scenarios_to_compare) == 0:
@@ -91,7 +91,7 @@ def comparision_scenarios_df():
 
 
 
-def plot_comparision_chart(df,metric):
+def plot_comparison_chart(df,metric):
     
     # Create traces for each column
     traces = []
@@ -107,7 +107,7 @@ def plot_comparision_chart(df,metric):
 
     # Create the layout
     layout = go.Layout(
-        title='Scenario Comparision '+ metric,
+        title='Scenario comparison '+ metric,
         xaxis_title="Channels",
         yaxis_title=metric,
         barmode='group'
@@ -118,12 +118,12 @@ def plot_comparision_chart(df,metric):
 
     return fig
 
-def create_comparision_plots():
-    comparision_scenarios_df()
-    spends_df, prospects_df = comparision_scenarios_df()
+def create_comparison_plots():
+    comparison_scenarios_df()
+    spends_df, prospects_df = comparison_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)
+    st.plotly_chart(plot_comparison_chart(spends_df,"Spends"),use_container_width=True)
+    st.plotly_chart(plot_comparison_chart(prospects_df,"Contributions"),use_container_width=True)
 
 def create_scenario_summary(scenario_dict):
     summary_rows = []
@@ -397,12 +397,12 @@ if auth_status == True:
         ]).to_html(),unsafe_allow_html=True)
         st.markdown("<br><br>", unsafe_allow_html=True)
         
-        with st.expander('Scenario Comparision'):
-            st.header("Scenario Comparision")
+        with st.expander('Scenario comparison'):
+            st.header("Scenario comparison")
             if len(scenarios_to_compare)== 0:
                 st.write("")
             else:
-                create_comparision_plots()
+                create_comparison_plots()
         
 elif auth_status == False:
     st.error('Username/Password is incorrect')
@@ -422,4 +422,4 @@ if auth_status != True:
 
 
 
-# create_comparision_plots()
+# create_comparison_plots()

pages/4_Model Quality.py

@@ -1,57 +0,0 @@
-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("")
-   

summary_df.pkl

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

utilities.py

@@ -372,6 +372,8 @@ def initialize_data(
                 "x0": params[3],
             },
             bounds=np.array([-10, 10]),
+            channel_bounds_min = 10,
+            channel_bounds_max = 10
         )
         channels[inp_col] = channel
         if sales is None: