m1

Model_Result_Overview.py

@@ -24,18 +24,123 @@ import yaml
 from yaml import SafeLoader
 import time
 from datetime import datetime,timedelta
-
+from pptx import Presentation
+from pptx.util import Inches
+from io import BytesIO
+import plotly.io as pio
+import response_curves_model_quality as rc1
 st.set_page_config(layout='wide')
 load_local_css('styles.css')
 set_header()
 
 st.title("Model Result Overview")
+def add_plotly_chart_to_slide(slide, fig, left, top, width, height):
+    img_stream = BytesIO()
+    pio.write_image(fig, img_stream, format='png',engine="orca")
+    slide.shapes.add_picture(img_stream, left, top, width, height)
+
+
+
+def save_table(df,prs):
+    # Add a blank slide
+    slide = prs.slides.add_slide(prs.slide_layouts[6])
+    
+    rows, cols = df.shape[0] + 1, df.shape[1]  # +1 for the header row
+    table = slide.shapes.add_table(rows, cols, Inches(1), Inches(1), Inches(10), Inches(7)).table
+
+    # Set the header row
+    for col_idx, col_name in enumerate(df.columns):
+        table.cell(0, col_idx).text = col_name
+
+    # Add the DataFrame rows to the table
+    for row_idx, row in df.iterrows():
+        for col_idx, value in enumerate(row):
+            # # print(value)
+            if isinstance(value, int):
+                table.cell(row_idx + 1, col_idx).text = str(value)
+
+
+def save_ppt_file(fig1,fig2,fig3,fig4,fig6,fig7,figw,start_date,end_date,shares_df1,shares_df2):
+    # Initialize PowerPoint presentation
+    prs = Presentation()
+
+    # save_table(shares_df1,prs)
+    # save_table(shares_df2,prs)  
+    # Slide 1: Model Quality with Chart
+    slide_1 = prs.slides.add_slide(prs.slide_layouts[6])
+    # title_1 = slide_1.shapes.title
+    # title_1.text = "Distribution Of Spends And Prospects"
+    # Add the Plotly chart to the slide
+    add_plotly_chart_to_slide(slide_1, sf.pie_contributions(start_date,end_date),  Inches(0.25), Inches(0.25), width=Inches(9.25), height=Inches(6.75))
+    add_plotly_chart_to_slide(prs.slides.add_slide(prs.slide_layouts[6]), sf.pie_spend(start_date,end_date),  Inches(0.25), Inches(0.25), width=Inches(9.25), height=Inches(6.75))
+    # Slide 2: Media Data Elasticity
+    slide_2 = prs.slides.add_slide(prs.slide_layouts[6])
+    # title_2 = slide_2.shapes.title
+    # title_2.text = "Media Contribution"
+    add_plotly_chart_to_slide(slide_2, fig2,  Inches(0.25), Inches(0.25), width=Inches(9.25), height=Inches(6.75))
+    slide_3 = prs.slides.add_slide(prs.slide_layouts[6])
+    # title_3 = slide_3.shapes.title
+    # title_3.text = "Media Spends"
+    add_plotly_chart_to_slide(slide_3, fig3,  Inches(0.25), Inches(0.25), width=Inches(9.25), height=Inches(6.75))
+    slide_4 = prs.slides.add_slide(prs.slide_layouts[6])
+    # title_4 = slide_4.shapes.title
+    # title_4.text = "CPP Distribution"
+    add_plotly_chart_to_slide(slide_4, fig4,  Inches(0.25), Inches(0.25), width=Inches(9.25), height=Inches(6.75))
+
+    if figw != None:
+        slide_5 = prs.slides.add_slide(prs.slide_layouts[6])
+        # title_5 = slide_5.shapes.title
+        # title_5.text = "Change in MMM Estimated Prospect Contributions"
+        figw.update_layout(
+        # title="Distribution Of Spends"
+        title={
+                    'text': "Change In MMM Estimated Prospect Contribution",
+                    'font': {
+                    'size': 24,
+                    'family': 'Arial',
+                    'color': 'black',
+                    # 'bold': True
+                }
+            }
+            
+    )
+        add_plotly_chart_to_slide(slide_5, figw, Inches(0.25), Inches(0.25), width=Inches(9.25), height=Inches(6.75))
+    else :
+        slide_5 = prs.slides.add_slide(prs.slide_layouts[5])
+        title_5 = slide_5.shapes.title
+        title_5.text = "Change in MMM Estimated Prospect Contributions"
+
+    slide_6 = prs.slides.add_slide(prs.slide_layouts[6])
+    # title_6 = slide_6.shapes.title
+    # title_6.text = "Base Decomposition"
+    add_plotly_chart_to_slide(slide_6, fig6, Inches(0.25), Inches(0.25), width=Inches(9.25), height=Inches(6.75))
+
+    slide_7 = prs.slides.add_slide(prs.slide_layouts[6])
+    # title_7 = slide_7.shapes.title
+    # title_7.text = "Media Decomposition"
+    add_plotly_chart_to_slide(slide_7, fig7,  Inches(0.25), Inches(0.25), width=Inches(9.25), height=Inches(6.75))
+
+    
+
+
+
+
+    # prs.save('MMM_Model_Result Overview.pptx')
+
+    # print("PowerPoint slides created successfully.")
+
+    # Save to a BytesIO object
+    ppt_stream = BytesIO()
+    prs.save(ppt_stream)
+    ppt_stream.seek(0)
+    
+    return ppt_stream.getvalue()
 
 def get_random_effects(media_data, panel_col, mdf):
     random_eff_df = pd.DataFrame(columns=[panel_col, "random_effect"])
 
     for i, market in enumerate(media_data[panel_col].unique()):
-        # print(i, end='\r')
+        # # print(i, end='\r')
         intercept = mdf.random_effects[market].values[0]
         random_eff_df.loc[i, 'random_effect'] = intercept
         random_eff_df.loc[i, panel_col] = market
@@ -130,12 +235,14 @@ if auth_status:
         #     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)
+        fig1 = sf.pie_charts(start_date,end_date)
+        st.plotly_chart(fig1,use_container_width=True)
 
          ## Channel Contribution Bar Chart
-        st.plotly_chart(sf.channel_contribution(start_date,end_date),use_container_width=True)
-        st.plotly_chart(sf.chanel_spends(start_date,end_date),use_container_width=True)
+        fig2 =sf.channel_contribution(start_date,end_date) 
+        st.plotly_chart(fig2,use_container_width=True)
+        fig3 = sf.chanel_spends(start_date,end_date)
+        st.plotly_chart(fig3,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)
@@ -146,15 +253,18 @@ if auth_status:
 
             # st.table(styled_df)
         shares_df = sf.shares_df_func(start_date,end_date)
+        shares_df1 = sf.shares_table_func(shares_df)
         st.dataframe(sf.shares_table_func(shares_df),use_container_width=True)
-        
+        shares_df2 = sf.eff_table_func(shares_df)
         st.dataframe(sf.eff_table_func(shares_df).style.format({"TOTAL SPEND": "{:,.0f}", "TOTAL SUPPORT": "{:,.0f}", "TOTAL CONTRIBUTION": "{:,.0f}"}),use_container_width=True)
 
             ### CPP CHART
-        st.plotly_chart(sf.cpp(start_date,end_date),use_container_width=True)
-    data_selection_type = st.radio("Select Input Type",["Compare Monthly Change", "Compare Custom Range"])
-    waterfall_start_date,waterfall_end_date = start_date,end_date
+        fig4 = sf.cpp(start_date,end_date)
+        st.plotly_chart(fig4,use_container_width=True)
+    
     with st.expander("View Change in MMM Estimated Prospect Contributions Analysis"):
+        data_selection_type = st.radio("Select Input Type",["Compare Monthly Change", "Compare Custom Range"])
+        waterfall_start_date,waterfall_end_date = start_date,end_date
         # Dropdown menu options
         st.markdown("<h1 style='font-size:28px;'>Change in MMM Estimated Prospect Contributions</h1>", unsafe_allow_html=True)
         if data_selection_type == "Compare Monthly Change":
@@ -255,8 +365,20 @@ if auth_status:
    
     with st.expander("View Decomposition Analysis"):    
         ### Base decomp CHART
-        st.plotly_chart(sf.base_decomp(),use_container_width=True)
+        fig6 = sf.base_decomp()
+        st.plotly_chart(fig6,use_container_width=True)
 
         ### Media decomp CHART
-        st.plotly_chart(sf.media_decomp(),use_container_width=True)
+        fig7 = sf.media_decomp()
+        st.plotly_chart(fig7,use_container_width=True)
+
+    if st.button("Prepare Download Of Analysis"):
+        ppt_file =  save_ppt_file(fig1,fig2,fig3,fig4,fig6,fig7,figw,start_date,end_date,shares_df1,shares_df2)
+        # Add a download button
+        st.download_button(
+            label="Download Analysis",
+            data=ppt_file,
+            file_name="MMM_Model_Result Overview.pptx",
+            mime="application/vnd.openxmlformats-officedocument.presentationml.presentation"
+        )
      

Streamlit_functions.py

@@ -128,6 +128,24 @@ def pie_charts(start_date,end_date):
     data2.index = channels
     data2.columns = ["p"]
 
+    colors = ['#ff2b2b',  # Pastel Peach
+    '#0068c9',  # Pastel Blue
+    '#83c9ff',  # Pastel Pink
+    
+    '#ffabab',  # Pastel Purple
+    '#29b09d',  # Pastel Green
+    '#7defa1',  # Pastel Yellow
+    '#ff8700',  # Pastel Gray
+    '#ffd16a',  # Pastel Red
+    '#6d3fc0',  # Pastel Rose
+    '#d5dae5',  # Pastel Lavender
+    '#309bff',  # Pastel Mauve
+    '#e9f5ff',  # Pastel Beige
+    '#BEBADA'   # Pastel Lilac
+    ]
+
+
+
     fig = make_subplots(rows=1, cols=2, specs=[[{'type':'domain'}, {'type':'domain'}]])
 
     fig.add_trace(go.Pie(labels=channels, 
@@ -137,6 +155,7 @@ def pie_charts(start_date,end_date):
                         textinfo= 'label+percent',
                         showlegend= False,textfont=dict(size =10),
                         title="Distribution of Spends"
+                        , marker=dict(colors=colors)
                         ), 1, 1)
 
     fig.add_trace(go.Pie(labels=channels, 
@@ -146,7 +165,7 @@ def pie_charts(start_date,end_date):
                         textinfo= 'label+percent',
                         showlegend= False,
                         textfont=dict(size = 10),
-                        title = "Distribution of Prospect Contributions"
+                        title = "Distribution of Prospect Contributions", marker=dict(colors=colors)
                         ), 1, 2)
     # fig.update_layout(
     #     title="Distribution Of Spends And Prospect Contributions"
@@ -180,6 +199,22 @@ def pie_charts(start_date,end_date):
     return fig
 
 def pie_spend(start_date,end_date):
+    colors = ['#ff2b2b',  # Pastel Peach
+    '#0068c9',  # Pastel Blue
+    '#83c9ff',  # Pastel Pink
+    
+    '#ffabab',  # Pastel Purple
+    '#29b09d',  # Pastel Green
+    '#7defa1',  # Pastel Yellow
+    '#ff8700',  # Pastel Gray
+    '#ffd16a',  # Pastel Red
+    '#6d3fc0',  # Pastel Rose
+    '#d5dae5',  # Pastel Lavender
+    '#309bff',  # Pastel Mauve
+    '#e9f5ff',  # Pastel Beige
+    '#BEBADA'   # Pastel Lilac
+    ]
+
     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)]
@@ -194,26 +229,26 @@ def pie_spend(start_date,end_date):
         textinfo= 'label+percent',
         showlegend= False,
         textfont=dict(size = 10)
-        
+        , marker=dict(colors=colors)
     )])
 
     # Customize the layout
-    # fig.update_layout(
-    #     # title="Distribution Of Spends"
-    #     title={
-    #                 'text': "Distribution Of Spends",
-    #                 'font': {
-    #                 'size': 24,
-    #                 'family': 'Arial',
-    #                 'color': 'black',
-    #                 # 'bold': True
-    #             }
-    #         }
+    fig.update_layout(
+        # title="Distribution Of Spends"
+        title={
+                    'text': "Distribution Of Spends",
+                    'font': {
+                    'size': 24,
+                    'family': 'Arial',
+                    'color': 'black',
+                    # 'bold': True
+                }
+            }
             
-    # )
+    )
 
     fig.add_annotation(
-        text=f"Distribution Of Spends </br> {start_date.strftime('%m-%d-%Y')} to {end_date.strftime('%m-%d-%Y')}",
+        text=f"{start_date.strftime('%m-%d-%Y')} to {end_date.strftime('%m-%d-%Y')}",
         x=0,
         y=1.15,
         xref="x domain",
@@ -226,6 +261,21 @@ def pie_spend(start_date,end_date):
     # Show the figure
     return fig
 def pie_contributions(start_date,end_date):
+    colors = ['#ff2b2b',  # Pastel Peach
+    '#0068c9',  # Pastel Blue
+    '#83c9ff',  # Pastel Pink
+    
+    '#ffabab',  # Pastel Purple
+    '#29b09d',  # Pastel Green
+    '#7defa1',  # Pastel Yellow
+    '#ff8700',  # Pastel Gray
+    '#ffd16a',  # Pastel Red
+    '#6d3fc0',  # Pastel Rose
+    '#d5dae5',  # Pastel Lavender
+    '#309bff',  # Pastel Mauve
+    '#e9f5ff',  # Pastel Beige
+    '#BEBADA'   # Pastel Lilac
+    ]
     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)]
@@ -241,16 +291,35 @@ def pie_contributions(start_date,end_date):
         textposition='auto',
         showlegend= False,
         textfont=dict(size = 10)
-        
+        , marker=dict(colors=colors)
     )])
 
     # fig.add_annotation(showarrow=False)
     # Customize the layout
     fig.update_layout(
-        title="Distribution Of Contributions",
+        # title="Distribution Of Contributions",
+        title={
+                    'text': "Distribution of Prospects",
+                    'font': {
+                    'size': 24,
+                    'family': 'Arial',
+                    'color': 'black',
+                    # 'bold': True
+                }
+            }
         # margin=dict(t=0, b=0, l=0, r=0)
     )
     
+    fig.add_annotation(
+        text=f"{start_date.strftime('%m-%d-%Y')} to {end_date.strftime('%m-%d-%Y')}",
+        x=0,
+        y=1.15,
+        xref="x domain",
+        yref="y domain",
+        showarrow=False,
+        font=dict(size=18),
+        # align='left'
+    )
 
     # Show the figure
     return fig
@@ -404,8 +473,8 @@ def waterfall2(start_date1,end_date1,start_date2,end_date2):
         font=dict(size=16),
         # align='left'
     )
-    # # print(cur_data)
-    # # print(prev_data)
+    # # # print(cur_data)
+    # # # print(prev_data)
     # fig.show()
     return fig
 def waterfall(start_date,end_date,btn_chart):
@@ -555,8 +624,8 @@ def waterfall(start_date,end_date,btn_chart):
         font=dict(size=16),
         # align='left'
     )
-    # # print(cur_data)
-    # # print(prev_data)
+    # # # print(cur_data)
+    # # # print(prev_data)
     # fig.show()
     return fig
 
@@ -855,12 +924,27 @@ def cpp(start_date,end_date):
         'rgba(240, 230, 140, 0.8)',   # Khaki
         'rgba(218, 112, 214, 0.8)'
     ]
+    colors = ['#ff2b2b',  # Pastel Peach
+    '#0068c9',  # Pastel Blue
+    '#83c9ff',  # Pastel Pink
+    
+    '#ffabab',  # Pastel Purple
+    '#29b09d',  # Pastel Green
+    '#7defa1',  # Pastel Yellow
+    '#ff8700',  # Pastel Gray
+    '#ffd16a',  # Pastel Red
+    '#6d3fc0',  # Pastel Rose
+    '#d5dae5',  # Pastel Lavender
+    '#309bff',  # Pastel Mauve
+    '#e9f5ff',  # Pastel Beige
+    '#BEBADA'   # Pastel Lilac
+    ]
 
     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]))
+        fig.add_trace(go.Scatter(x=cpp_df['Date'], y=cpp_df[channels[i]+"_cpp"], mode='lines', name=channels[i], line=dict(color=colors[i])))
 
     # Update layout for better visualization
     fig.update_layout(
@@ -915,11 +999,14 @@ def base_decomp():
 
     base_decomp_df = df[['Date','Unemployment', 'Competition','Trend','Seasonality','Base_0']]
     fig = go.Figure()
-
+    colors = ['#ff2b2b',  # Pastel Peach
+    '#0068c9',  # Pastel Blue
+    '#83c9ff',  # Pastel Pink
+    ]
     # 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'))
+    fig.add_trace(go.Scatter(x=base_decomp_df['Date'], y=base_decomp_df['Base_0'], mode='lines', name='Trend and Seasonality',line=dict(color=colors[0])))
+    fig.add_trace(go.Scatter(x=base_decomp_df['Date'], y=base_decomp_df['Unemployment'], mode='lines', name='Unemployment',line=dict(color=colors[1])))
+    fig.add_trace(go.Scatter(x=base_decomp_df['Date'], y=base_decomp_df['Competition'], mode='lines', name='Competition',line=dict(color=colors[2])))
 
     # Update layout for better visualization
     fig.update_layout(
@@ -997,7 +1084,7 @@ def media_decomp():
 
     media_cols = media_decomp_df.columns
     for i in range(2,len(media_cols)):
-    #     # print(media_cols[i])
+    #     # # print(media_cols[i])
         cumulative_df[media_cols[i]] = cumulative_df[media_cols[i]] + cumulative_df[media_cols[i-1]]
     # cumulative_df
 
@@ -1079,8 +1166,8 @@ def mmm_model_quality():
     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)'))
+    fig.add_trace(go.Scatter(x=base_df['Date'], y=base_df['Y_hat'], mode='lines', name='Predicted',line=dict(color='#CC5500') ))
+    fig.add_trace(go.Scatter(x=base_df['Date'], y=base_df['Y'], mode='lines', name='Actual (Prospect)',line=dict(color='#4B88FF')))
 
 
     # Update layout for better visualization
@@ -1467,7 +1554,7 @@ def scenario_spend_forecasting2(delta_df,start_date,end_date):
             return "Invalid month number"
     
     data2["Month year"] = data2["Month"].apply(get_month_name) + ' ' +(data2["Date"].dt.year+1).astype(str)   
-    # print(data2.columns)
+    # # print(data2.columns)
     data2 = data2[['Month year' ,'BROADCAST TV', 'CABLE TV',
        'CONNECTED & OTT TV', 'VIDEO', 'DISPLAY PROSPECTING',
        'DISPLAY RETARGETING', 'SOCIAL PROSPECTING', 'SOCIAL RETARGETING',

classes.py

@@ -100,7 +100,7 @@ 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
-        # print(self.actual_total_spends)
+        # # # print(self.actual_total_spends)
     def update_penalty(self, penalty):
         self.penalty = penalty
 
@@ -108,23 +108,25 @@ class Channel:
         return spends_array * total_spends / spends_array.sum()
 
     def modify_spends(self, total_spends):
-        self.modified_spends = (
-            self.modified_spends * total_spends / self.modified_spends.sum()
-        )
-        print("modified spends")
-        print(self.modified_spends)
+        # # # print(total_spends)
+        self.modified_spends[0] = total_spends 
+        # (
+        #     self.modified_spends * total_spends / self.modified_spends.sum()
+        # )
+        # # # print("in spends")
+        # # # print(self.modified_spends,self.modified_spends.sum())
 
     def calculate_sales(self):
-        print("in calc_sales")
-        print(self.modified_spends)
+        # # # print("in calc_sales")
+        # # # print(self.modified_spends)
         return self.response_curve(self.modified_spends)
 
     def hill_equation(x, Kd, n):
         return x**n / (Kd**n + x**n)
     def response_curve(self, x):
-        print(x)
+        # # # print(x)
         # if self.penalty:
-        #     print("in penalty")
+        #     # # print("in penalty")
         #     x = np.where(
         #         x < self.upper_limit,
         #         x,
@@ -132,14 +134,14 @@ class Channel:
         #     )
         if self.response_curve_type == "hill-eq":
             # dividing_parameter = check_dividing_parameter()
-            # print("lalala")
-            # # print(self.name)\
-            # print(len(x))
-            print("in response curve function")
-            print(x)
+            # # # print("lalala")
+            # # # # print(self.name)\
+            # # # print(len(x))
+            # # # print("in response curve function")
+            # # # print(x)
             if len(x) == 1:
                 dividing_rate = self.response_curve_params["num_pos_obsv"]
-                # print(dividing_rate)
+                # # # print(dividing_rate)
                 # x = np.sum(x)
             else:
                 dividing_rate = 1
@@ -152,14 +154,14 @@ class Channel:
             x_max= self.response_curve_params["x_max"]
             y_min= self.response_curve_params["y_min"]
             y_max= self.response_curve_params['y_max']  
-            # # print(x_min)
-            # # print(Kd,n,x_min,x_max,y_min,y_max)
-            # # print(np.sum(x)/104)
+            # # # # print(x_min)
+            # # # # print(Kd,n,x_min,x_max,y_min,y_max)
+            # # # # print(np.sum(x)/104)
             x_inp = ( x/dividing_rate- x_min) / (x_max - x_min)
-            # # print("x",x)
-            # # print("x_inp",x_inp)
+            # # # # print("x",x)
+            # # # # print("x_inp",x_inp)
             x_out = x_inp**n / (Kd**n + x_inp**n) #self.hill_equation(x_inp,Kd, n)
-            # # print("x_out",x_out)
+            # # # # print("x_out",x_out)
 
 
             x_val_inv = (x_out*x_max + (1 - x_out) * x_min)
@@ -167,12 +169,12 @@ class Channel:
             # sales = ((x_max - x_min)*x_out + x_min)*dividing_rate
 
             sales[np.isnan(sales)] = 0
-            # # print(sales) 
-            # # print(np.sum(sales))
-            # # print("sales",sales)
-            print("aa")
-            print(sales)
-            print("aa1")
+            # # # # print(sales) 
+            # # # # print(np.sum(sales))
+            # # # # print("sales",sales)
+            # # # print("aa")
+            # # # print(sales)
+            # # # print("aa1")
         if self.response_curve_type == "s-curve":
             if self.power >= 0:
                 x = x / 10**self.power
@@ -289,23 +291,24 @@ class Scenario:
 
     def calculate_actual_total_sales(self):
         total_actual_sales = 0#self.constant.sum()  + self.correction.sum()
-        # print("a")
+        # # # print("a")
         for channel in self.channels.values():
             total_actual_sales += channel.actual_total_sales
-            # # print(channel.actual_total_sales)
-        # # print(total_actual_sales)
+            # # # # print(channel.actual_total_sales)
+        # # # # print(total_actual_sales)
         return total_actual_sales
 
     def calculate_modified_total_sales(self):
 
         total_modified_sales = 0 #self.constant.sum() + self.correction.sum()
-        # print(total_modified_sales)
+        # # # print(total_modified_sales)
         for channel in self.channels.values():
-            # print(channel,channel.modified_total_sales)
+            # # # print(channel,channel.modified_total_sales)
             total_modified_sales += channel.modified_total_sales
         return total_modified_sales
 
     def update(self, channel_name, modified_spends):
+        # # # print("in updtw")
         self.channels[channel_name].update(modified_spends)
         self.modified_total_sales = self.calculate_modified_total_sales()
         self.modified_total_spends = self.calculate_modified_total_spends()
@@ -363,21 +366,33 @@ class Scenario:
     
 
     def optimize_spends(self, sales_percent, channels_list, algo="trust-constr"):
-        # # print("%"*100)
+        num_channels = len(channels_list)
+        # # # # print("%"*100)
         desired_sales = self.actual_total_sales * (1 + sales_percent / 100.0)
 
         def constraint(x):
             for ch, spends in zip(channels_list, x):
                 self.update(ch, spends)
             return self.modified_total_sales - desired_sales
+        
+        # def calc_overall_bounds(channels_list):
+        #     total_spends=0
+        #     for ch in zip(channels_list):
+        #         print(ch)
+        #         total_spends= total_spends+self.channels[ch].actual_total_spends
+        #     return total_spends
+
 
         bounds = []
         for ch in channels_list:
-            bounds.append(
-                (1+np.array([-50.0, 100.0]) / 100.0)
-                * self.channels[ch].actual_total_spends
-            )
-            # # print(self.channels[ch].actual_total_spends)
+            # bounds.append(
+            #     (1+np.array([-50.0, 100.0]) / 100.0)
+            #     * self.channels[ch].actual_total_spends
+            # )
+            lb = (1- int(self.channels[ch].channel_bounds_min) / 100) * self.channels[ch].actual_total_spends
+            ub = (1+  int(self.channels[ch].channel_bounds_max) / 100)  * self.channels[ch].actual_total_spends
+            bounds.append((lb,ub))
+            # # # # print(self.channels[ch].actual_total_spends)
         initial_point = []
         for bound in bounds:
             initial_point.append(bound[0])
@@ -385,7 +400,9 @@ class Scenario:
 
         power = np.ceil(np.log(sum(initial_point)) / np.log(10))
 
-        constraints = [NonlinearConstraint(constraint, -1.0, 1.0)]
+        constraints = [NonlinearConstraint(constraint, -1.0, 1.0),
+                    #    LinearConstraint(np.ones((num_channels,)), lb = -50*calc_overall_bounds(channels_list), ub = 50*calc_overall_bounds(channels_list))
+                       ]
 
         res = minimize(
             lambda x: sum(x) / 10 ** (power),
@@ -411,12 +428,13 @@ class Scenario:
         for channel_name in channels_list:
             # spends_constraint += self.channels[channel_name].modified_total_spends
             spends_constant.append(self.channels[channel_name].conversion_rate)
-            # print(spends_constant)
+            # # # print(spends_constant)
             spends_constraint += (
-                self.channels[channel_name].actual_total_spends
-                * 1.0
+                self.channels[channel_name].actual_total_spends+ self.channels[channel_name].delta_spends
+                #* (1 + self.channels[channel_name].delta_spends / 100)
             )
-        spends_constraint = spends_constraint * (1 + spends_percent / 100)
+            # # # print("delta spends",self.channels[channel_name].delta_spends)
+        # spends_constraint = spends_constraint * (1 + spends_percent / 100)
         constraint= LinearConstraint(np.ones((num_channels,)), lb = spends_constraint, ub = spends_constraint)
         # constraint = LinearConstraint(
         #     np.array(spends_constant),
@@ -428,14 +446,17 @@ class Scenario:
         for channel_name in channels_list:
             _channel_class = self.channels[channel_name]
             channel_bounds = _channel_class.bounds
-            channel_actual_total_spends = _channel_class.actual_total_spends * (
-                (1 + spends_percent / 100)
-            )
+            channel_actual_total_spends = _channel_class.actual_total_spends + _channel_class.delta_spends 
+            # * (
+            #     (1 + _channel_class.delta_spends / 100)
+            # )
             old_spends.append(channel_actual_total_spends)
             # bounds.append((1+ channel_bounds / 100) * channel_actual_total_spends)
-            lb = (1- _channel_class.channel_bounds_min / 100) * channel_actual_total_spends
-            ub = (1+ _channel_class.channel_bounds_max / 100) * channel_actual_total_spends
+            lb = (1- int(_channel_class.channel_bounds_min) / 100) * _channel_class.actual_total_spends
+            ub = (1+  int(_channel_class.channel_bounds_max) / 100)  * _channel_class.actual_total_spends
             bounds.append((lb,ub))
+            # # # print("aaaaaa")
+            # # print((_channel_class.channel_bounds_max,_channel_class.channel_bounds_min))
             # _channel_class.channel_bounds_min
             # _channel_class.channel_bounds_max
         def cost_func1(channel,x):
@@ -450,44 +471,44 @@ class Scenario:
             y_max= param_dicts['y_max'][channel] 
             division_parameter = param_dicts['num_pos_obsv'][channel] 
             x_inp = ( x/division_parameter- x_min) / (x_max - x_min)
-        #     print(x_inp)
+        #     # # print(x_inp)
             x_out = x_inp**n / (Kd**n + x_inp**n)
             x_val_inv = (x_out*x_max + (1 - x_out) * x_min)
             sales = (x_val_inv*y_min/y_max)*division_parameter
             if np.isnan(sales):
-        #         print(sales,channel)
+        #         # # print(sales,channel)
                 sales = 0
-            # print(sales,channel)
+            # # # print(sales,channel)
             return sales
         def objective_function(x):
-            modified_total_sales = 0
+            sales = 0
+            it = 0
             for channel_name, modified_spends in zip(channels_list, x):
-                modified_total_sales = modified_total_sales + cost_func1(channel_name,modified_spends)
-                # self.update(channel_name, modified_spends)
+                # sales = sales + cost_func1(channel_name,modified_spends)
+                # print(channel_name, modified_spends,cost_func1(channel_name, modified_spends))
+                it+=1
+                self.update(channel_name, modified_spends)
+            # # # print(self.modified_total_sales)
+            # # # print(channel_name, modified_spends)
             return -1 * self.modified_total_sales
 
-        print(bounds)
-        # # print("$"*100)
+        # # # print(bounds)
+        # # # # print("$"*100)
         res = minimize(
-            lambda x: objective_function(x)  / 1e3,
+            lambda x: objective_function(x)/1e3,
             method="trust-constr",
             x0=old_spends,
             constraints=constraint,
             bounds=bounds,
             options={"maxiter": int(1e7), "xtol": 0.1},
         )
-        # res = dual_annealing(
-        # objective_function,
-        # x0=old_spends,
-        # mi
-        # constraints=constraint,
-        # bounds=bounds,
-        # tol=1e-16
-        # )
-        # # print(res)
+
         for channel_name, modified_spends in zip(channels_list, res.x):
+            # # # print("aaaaaaaaaaaaaa")
             self.update(channel_name, modified_spends)
-            print(channel_name, modified_spends,cost_func1(channel_name, modified_spends))
+            # # # print(channel_name, modified_spends,cost_func1(channel_name, modified_spends))
+            
+            # print(it)
 
         return zip(channels_list, res.x)
     
@@ -512,7 +533,7 @@ class Scenario:
 
     #     x_vars=[]
     #     x_vars = [m.Var(value=param_dicts["current_spends"][_], lb=param_dicts["x_min"][_]*104, ub=5*param_dicts["current_spends"][_]) for _ in channels_list]
-    #     # print(x_vars)
+    #     # # # print(x_vars)
     # #     x_vars,lower_bounds
         
     #     # Define the objective function to minimize
@@ -520,8 +541,8 @@ class Scenario:
     #     spends = 0 
     #     i = 0
     #     for i,c in enumerate(channels_list):
-    #         # # print(c)
-    #         # # print(x_vars[i])
+    #         # # # # print(c)
+    #         # # # # print(x_vars[i])
     #         cost = cost + (self.cost_func(c, x_vars[i]))
     #         spends = spends +x_vars[i]
 
@@ -536,7 +557,7 @@ class Scenario:
     #     m.solve(disp=True)
         
     #     for i, var in enumerate(x_vars):
-    #         # print(f"x{i+1} = {var.value[0]}")
+    #         # # # print(f"x{i+1} = {var.value[0]}")
         
     #     for channel_name, modified_spends in zip(channels_list, x_vars):
     #         self.update(channel_name, modified_spends.value[0])

pages/1_Model_Quality.py

@@ -7,13 +7,126 @@ import response_curves_model_quality_base as rc1
 st.set_page_config(
     layout="wide"
 )   
+from pptx import Presentation
+from pptx.util import Inches
+from io import BytesIO
+import plotly.io as pio
+import Streamlit_functions as sf
+import response_curves_model_quality_base as rc1
+
+
+def save_ppt_file():
+
+    # Initialize PowerPoint presentation
+    prs = Presentation()
+    # Helper function to add Plotly figure to slide
+    def add_plotly_chart_to_slide(slide, fig, left, top, width, height):
+        img_stream = BytesIO()
+        pio.write_image(fig, img_stream, format='png',engine="orca")
+        slide.shapes.add_picture(img_stream, left, top, width, height)
+
+    # Slide 1: Model Quality with Chart
+    slide_1 = prs.slides.add_slide(prs.slide_layouts[5])
+    title_1 = slide_1.shapes.title
+    title_1.text = "Model Quality"
+    i = 0 
+    # print (i)
+    # Generate Plotly chart
+    fig = sf.mmm_model_quality()
+
+    # Add the Plotly chart to the slide
+    add_plotly_chart_to_slide(slide_1, fig, Inches(1), Inches(2), width=Inches(9), height=Inches(4.5))
+    i = i+1
+    # print (i)
+    # Slide 2: Media Data Elasticity
+    slide_2 = prs.slides.add_slide(prs.slide_layouts[5])
+    title_2 = slide_2.shapes.title
+    title_2.text = "Media Data Elasticity"
+    i = i+1
+    # print (i)
+    # Generate Elasticity chart
+    media_df = sf.media_data()
+    fig = sf.elasticity(media_df)
+    fig.update_layout(
+        margin=dict(l=150, r=50, t=50, b=50),  # Adjust margins
+        # xaxis=dict(tickangle=-45)  # Rotate x-axis labels if needed
+    )
+    i = i+1
+    # print (i)
+    # Add the Plotly chart to the slide
+    add_plotly_chart_to_slide(slide_2, fig, Inches(1), Inches(2), width=Inches(8), height=Inches(4.5))
+    i = i+1
+    # print (i)
+    # Slide 3: Half-Life Analysis
+    slide_3 = prs.slides.add_slide(prs.slide_layouts[5])
+    title_3 = slide_3.shapes.title
+    title_3.text = "Half-Life Analysis"
+    i = i+1
+    # print (i)
+    # Generate Half-Life chart
+    fig = sf.half_life(media_df)
+    fig.update_layout(
+        margin=dict(l=150, r=100, t=50, b=50),  # Adjust margins
+        # xaxis=dict(tickangle=-45)  # Rotate x-axis labels if needed
+    )
+    i = i+1
+    # print (i)
+    # Add the Plotly chart to the slide
+    add_plotly_chart_to_slide(slide_3, fig, Inches(1), Inches(2), width=Inches(8), height=Inches(4.5))
+    i = i+1
+    # print (i)
+    # Slide 4: Response Curves
+
+    # Generate Response Curves chart
+    channels = [
+        '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']
+    i = 4
+    for channel_name in channels:
+        slide_4 = prs.slides.add_slide(prs.slide_layouts[5])
+        title_4 = slide_4.shapes.title
+        title_4.text = "Response Curves"
+        i = i+1
+        # print (i)
+        selected_option = channel_name 
+        selected_option2 = 'View Line Plot'
+        fig = rc1.response_curves(selected_option, selected_option2)
+        # Add the Plotly chart to the slide
+        add_plotly_chart_to_slide(slide_4, fig, Inches(1), Inches(2), width=Inches(6), height=Inches(4.5))
+    # Save the PowerPoint presentation
+    # prs.save('MMM_Model_Quality_Presentation.pptx')
+    # # print("PowerPoint slides created successfully.")
+
+    # Save to a BytesIO object
+    ppt_stream = BytesIO()
+    prs.save(ppt_stream)
+    ppt_stream.seek(0)
+    
+    return ppt_stream.getvalue()
+
+
 
 
 st.header("Model Quality")
 # st.write("MMM Model Quality")
 
 st.plotly_chart(sf.mmm_model_quality(),use_container_width=True)
-    
+fig = sf.mmm_model_quality()
+# print("aaa")
+fig.write_image("chart.png",engine="orca")
+# print("bbb")
+
 media_df = sf.media_data()
     # Create two columns for start date and end date input
 col1, col2 , col3 = st.columns([1,0.2,1])
@@ -23,10 +136,14 @@ st.dataframe(df1,hide_index  = True,use_container_width=True)
 # st.plotly_chart(sf.elasticity_and_media(media_df))
 with col1:
     st.plotly_chart(sf.elasticity(media_df))
+    fig = sf.elasticity(media_df)
+    fig.write_image("chart.png",engine="orca")
 with col2:
     st.write("")
 with col3:
     st.plotly_chart(sf.half_life(media_df))
+    fig = sf.elasticity(media_df)
+    fig.write_image("chart.png",engine="orca")
     
 
 # Dropdown menu options
@@ -57,4 +174,16 @@ with col1:
     
 with col2:
     st.write("")
-st.plotly_chart(rc1.response_curves(selected_option,selected_option2))  
+st.plotly_chart(rc1.response_curves(selected_option,selected_option2))  
+
+if st.button("Prepare Analysis Download"):
+    ppt_file =  save_ppt_file()
+        # Add a download button
+    st.download_button(
+            label="Download Analysis",
+            data=ppt_file,
+            file_name="MMM_Model_Quality_Presentation.pptx",
+            mime="application/vnd.openxmlformats-officedocument.presentationml.presentation"
+        )
+     
+

pages/2_Scenario_Planner.py

@@ -40,6 +40,11 @@ st.set_page_config(layout="wide")
 load_local_css("styles.css")
 set_header()
 
+from pptx import Presentation
+from pptx.util import Inches
+from io import BytesIO
+import plotly.io as pio
+
 
 for k, v in st.session_state.items():
     if k not in ["logout", "login", "config"] and not k.startswith("FormSubmitter"):
@@ -48,6 +53,73 @@ for k, v in st.session_state.items():
 # ======================= Functions ====================== #
 # ======================================================== #
 
+    
+def save_ppt_file(summary_df_sorted,fig1,fig2,fig3):
+    summary_df_sorted.index = summary_df_sorted["Channel_name"]
+    # Initialize PowerPoint presentation
+    prs = Presentation()
+    # Helper function to add Plotly figure to slide
+    def add_plotly_chart_to_slide(slide, fig, left, top, width, height):
+        img_stream = BytesIO()
+        pio.write_image(fig, img_stream, format='png',engine="orca")
+        slide.shapes.add_picture(img_stream, left, top, width, height)
+
+    for i in range(0,len(channels_list)):
+        # print(channels_list[i])
+        slide_1 = prs.slides.add_slide(prs.slide_layouts[6])
+        fig = rc.response_curves(channels_list[i], summary_df_sorted["Optimized_spend"][channels_list[i]], summary_df_sorted["New_sales"][channels_list[i]])
+        add_plotly_chart_to_slide(slide_1, fig, Inches(0.1), Inches(0.1), width=Inches(9), height=Inches(7))
+
+    # Update layout
+    fig1.update_layout(
+        legend=dict(
+            orientation="h",  # Horizontal orientation
+            yanchor="top",    # Anchor the legend at the top
+            y=-0.4,           # Position the legend below the plot area
+            xanchor="center", # Center the legend horizontally
+            x=0.5            # Center the legend on the x-axis
+        )
+    )
+    # Update layout
+    fig2.update_layout(
+                legend=dict(
+            orientation="h",  # Horizontal orientation
+            yanchor="top",    # Anchor the legend at the top
+            y=-0.4,           # Position the legend below the plot area
+            xanchor="center", # Center the legend horizontally
+            x=0.5            # Center the legend on the x-axis
+        )
+    )
+    # Update layout
+    fig3.update_layout(
+        legend=dict(
+            orientation="h",  # Horizontal orientation
+            yanchor="top",    # Anchor the legend at the top
+            y=-0.4,           # Position the legend below the plot area
+            xanchor="center", # Center the legend horizontally
+            x=0.5            # Center the legend on the x-axis
+        )
+    )
+
+
+
+    slide_1 = prs.slides.add_slide(prs.slide_layouts[6])
+
+    add_plotly_chart_to_slide(slide_1, fig1, Inches(0.1), Inches(1), width=Inches(9.5), height=Inches(6))
+    slide_1 = prs.slides.add_slide(prs.slide_layouts[6])
+    add_plotly_chart_to_slide(slide_1, fig2, Inches(0.1), Inches(1), width=Inches(9.5), height=Inches(6))
+    slide_1 = prs.slides.add_slide(prs.slide_layouts[6])
+    add_plotly_chart_to_slide(slide_1, fig3, Inches(0.1), Inches(1), width=Inches(9.5), height=Inches(6))
+
+
+
+    # Save to a BytesIO object
+    ppt_stream = BytesIO()
+    prs.save(ppt_stream)
+    ppt_stream.seek(0)
+    
+    return ppt_stream.getvalue()
+
 def first_day_of_next_year(date):
     next_year = date.year + 1
     first_day = datetime(next_year, 1, 1).date()
@@ -91,15 +163,15 @@ def optimize(key, status_placeholder):
         if key.lower() == "media spends":
             with status_placeholder:
                 with st.spinner("Optimizing"):
-                    # # print(channel_list)
-                    # # print(st.session_state["total_spends_change"])
+                    # # # print(channel_list)
+                    # # # print(st.session_state["total_spends_change"])
                     result = st.session_state["scenario"].optimize(
                         st.session_state["total_spends_change"], channel_list
                         # result = st.session_state["scenario"].spends_optimisation(
                         # st.session_state["total_spends_change"], channel_list
                     )
-                    print("")
-                    print(list(zip(*result)))
+                    # print("")
+                    # print(list(zip(*result)))
 
     
 
@@ -142,7 +214,7 @@ def save_scenario(scenario_name):
         st.session_state["scenario"]
     )
     st.session_state["scenario_input"] = ""
-    # # print(type(st.session_state['saved_scenarios']))
+    # # # print(type(st.session_state['saved_scenarios']))
     with open("../saved_scenarios.pkl", "wb") as f:
         pickle.dump(st.session_state["saved_scenarios"], f)
 
@@ -219,9 +291,9 @@ def update_sales():
 # 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)
+#         # # 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"]
@@ -237,6 +309,7 @@ def update_sales():
 
 
 def update_all_spends_abs():
+    st.write("aon update spends abs")
     if (
         st.session_state["total_spends_change_abs"]
         in st.session_state["total_spends_change_abs_slider_options"]
@@ -244,6 +317,7 @@ def update_all_spends_abs():
         st.session_state["allow_spends_update"] = True
     else:
         st.session_state["allow_spends_update"] = False
+        # st.warning("Invalid Input")
 
     actual_spends = _scenario.actual_total_spends
     if (
@@ -417,7 +491,7 @@ def update_penalty():
 
 
 def reset_scenario(panel_selected, file_selected, updated_rcs):
-    # ## print(st.session_state['default_scenario_dict'])
+    # ## # 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)
@@ -556,13 +630,13 @@ def calculate_rgba(
 
 
 def debug_temp(x_test, power, K, b, a, x0):
-    # # print("*" * 100)
+    # # # 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(
+    # # # print(
     #     f"""
     #         lower : {count_lower_bin}
     #         center : {count_center_bin}
@@ -596,7 +670,7 @@ def plot_response_curves(summary_df_sorted):
     '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)]
+    figures = [rc.response_curves(channels_list[i], summary_df_sorted["Optimized_spend"][channels_list[i]], summary_df_sorted["New_sales"][channels_list[i]]) for i in range(13)]
 
     # for i in range()
     
@@ -647,14 +721,14 @@ def upload_file_prospects_calc(df):
     params = pd.read_excel(r"response_curves_parameters.xlsx",index_col = "channel")
     param_dicts = {col: params[col].to_dict() for col in params.columns}
     df.index = df.channel
-#     # print(param_dicts)
+#     # # print(param_dicts)
     for col in df.channel:
         x = df["Spends"][col]
         dividing_rate = 104
         # st.write(x)
         x_inp = ( x/dividing_rate- param_dicts["x_min"][col]) / (param_dicts["x_max"][col] - param_dicts["x_min"][col])
         x_out = x_inp**param_dicts["n"][col] / (param_dicts["Kd"][col]**param_dicts["n"][col] + x_inp**param_dicts["n"][col]) #self.hill_equation(x_inp,Kd, n)
-            # # print("x_out",x_out)
+            # # # print("x_out",x_out)
 
 
         x_val_inv = (x_out*param_dicts["x_max"][col] + (1 - x_out) * param_dicts["x_min"][col])
@@ -665,7 +739,7 @@ def upload_file_prospects_calc(df):
         # x_out = x**param_dicts["n"][col]/(param_dicts["Kd"][col]**param_dicts["n"][col]+ x**param_dicts["n"][col])
         # x_out_inv = (x_out*(param_dicts["y_max"][col]-param_dicts["y_min"][col])+param_dicts["y_min"][col])*104
         df["Prospects"][col] = sales
-    # # print(df)
+    # # # print(df)
     return df
     
 
@@ -781,6 +855,105 @@ def reset_inputs():
 
     st.session_state["initialized"] = False
 
+def scenario_planner_plots2():
+    import plotly.graph_objects as go
+    from plotly.subplots import make_subplots
+
+        
+    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)'
+
+    fig1 = go.Figure()
+        # Add actual vs optimized spend bars
+
+            
+    fig1.add_trace(go.Bar(x=summary_df_sorted['Channel_name'].apply(channel_name_formating), 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))
+            
+            
+    fig1.add_trace(go.Bar(x=summary_df_sorted['Channel_name'].apply(channel_name_formating), 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))
+            
+    fig1.update_xaxes(title_text="Channels")
+    fig1.update_yaxes(title_text="Spends ($)")
+    fig1.update_layout(
+    title = "Actual vs. Optimized Spends",
+                     margin=dict(t=40, b=40, l=40, r=40)
+              )
+            
+        # st.plotly_chart(fig1,use_container_width=True)
+
+            # Add actual vs optimized Contribution
+    fig2 = go.Figure()
+    fig2.add_trace(go.Bar(x=summary_df_sorted['Channel_name'].apply(channel_name_formating), 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))
+            
+    fig2.add_trace(go.Bar(x=summary_df_sorted['Channel_name'].apply(channel_name_formating), 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))
+            
+            
+    
+    fig2.update_yaxes(title_text="Contribution")
+    fig2.update_xaxes(title_text="Channels") 
+    fig2.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(fig2,use_container_width=True)
+
+        # Add actual vs optimized Efficiency bars
+    fig3 = go.Figure()
+    summary_df_sorted_p =  summary_df_sorted[summary_df_sorted['Channel_name']!="Panel"]
+    fig3.add_trace(go.Bar(x=summary_df_sorted_p['Channel_name'].apply(channel_name_formating), 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))
+    fig3.add_trace(go.Bar(x=summary_df_sorted_p['Channel_name'].apply(channel_name_formating), 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))
+            
+    fig3.update_xaxes(title_text="Channels")
+    fig3.update_yaxes(title_text="Efficiency")
+    fig3.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(fig3,use_container_width=True)
+    return fig1,fig2,fig3 
 def scenario_planner_plots():
     with st.expander('Optimized Spends Overview'):
     # if st.button('Refresh'):
@@ -823,11 +996,11 @@ def scenario_planner_plots():
         light_red = 'rgba(250, 110, 10, 0.7)'
         light_purple = 'rgba(255, 191, 69, 0.7)'
 
-        fig = go.Figure()
+        fig1 = go.Figure()
         # Add actual vs optimized spend bars
 
             
-        fig.add_trace(go.Bar(x=summary_df_sorted['Channel_name'].apply(channel_name_formating), y=summary_df_sorted['Actual_spend'], name='Actual',
+        fig1.add_trace(go.Bar(x=summary_df_sorted['Channel_name'].apply(channel_name_formating), y=summary_df_sorted['Actual_spend'], name='Actual',
                                 text=summary_df_sorted['Actual_spend'].apply(format_number) + ' '
                                 #  + 
                                 #  ' '+
@@ -836,62 +1009,63 @@ def scenario_planner_plots():
                                 marker_color=light_blue))
             
             
-        fig.add_trace(go.Bar(x=summary_df_sorted['Channel_name'].apply(channel_name_formating), y=summary_df_sorted['Optimized_spend'], name='Optimized',
+        fig1.add_trace(go.Bar(x=summary_df_sorted['Channel_name'].apply(channel_name_formating), 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(
+        fig1.update_xaxes(title_text="Channels")
+        fig1.update_yaxes(title_text="Spends ($)")
+        fig1.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(fig1,use_container_width=True)
 
             # Add actual vs optimized Contribution
-        fig = go.Figure()
-        fig.add_trace(go.Bar(x=summary_df_sorted['Channel_name'].apply(channel_name_formating), y=summary_df_sorted['Old_sales'], 
+        fig2 = go.Figure()
+        fig2.add_trace(go.Bar(x=summary_df_sorted['Channel_name'].apply(channel_name_formating), 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'].apply(channel_name_formating), y=summary_df_sorted['New_sales'],
+        fig2.add_trace(go.Bar(x=summary_df_sorted['Channel_name'].apply(channel_name_formating), 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(
+        fig2.update_yaxes(title_text="Contribution")
+        fig2.update_xaxes(title_text="Channels") 
+        fig2.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(fig2,use_container_width=True)
 
         # Add actual vs optimized Efficiency bars
-        fig = go.Figure()
+        fig3 = 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'].apply(channel_name_formating), y=summary_df_sorted_p['old_efficiency'], 
+        fig3.add_trace(go.Bar(x=summary_df_sorted_p['Channel_name'].apply(channel_name_formating), 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'].apply(channel_name_formating), y=summary_df_sorted_p['new_efficiency'], 
+        fig3.add_trace(go.Bar(x=summary_df_sorted_p['Channel_name'].apply(channel_name_formating), 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(
+        fig3.update_xaxes(title_text="Channels")
+        fig3.update_yaxes(title_text="Efficiency")
+        fig3.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(fig3,use_container_width=True)
+        return fig1,fig2,fig3
 
 def give_demo():
     def get_file_bytes(file_path):
@@ -1035,7 +1209,7 @@ if auth_status == True:
         # ========================== UI ========================== #
         # ======================================================== #
 
-        # # print(list(st.session_state.keys()))
+        # # # 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"]
@@ -1071,7 +1245,7 @@ if auth_status == True:
             st.session_state["lower_bound_key"] = 10
         
         if "upper_bound_key" not in st.session_state:
-            st.session_state["upper_bound_key"] = 10
+            st.session_state["upper_bound_key"] = 100
 
         # st.write(_scenario.modified_total_sales)
         header_df = pd.DataFrame(index=["Actual","Simulated","Change","Percent Change"],columns=["Spends","Prospects"])
@@ -1377,12 +1551,9 @@ if auth_status == True:
                 )
 
             with _columns1[2]:
-                # st.button(
-                #     "Optimize",
-                #     on_click=optimize,
-                #     args=(st.session_state["optimization_key"]),
-                #     use_container_width=True,
-                # )
+                # 
+                
+
 
                 optimize_placeholder = st.empty()
 
@@ -1399,6 +1570,24 @@ if auth_status == True:
 
             _columns2 = st.columns((2, 2, 2,2))
             if st.session_state["optimization_key"] == "Media Spends":
+                # st.write(overall_lower_bound,overall_upper_bound)
+                
+                with _columns2[2]:
+                    overall_lower_bound = st.number_input(
+                            "Overall Lower Bound for Spends",
+                            value = 50.0,
+                            key = "overall_lower_bound",
+                            # on_change=partial(update_data_bound_min_overall)
+                        )
+                with _columns2[3]:
+                    overall_upper_bound = st.number_input(
+                            "Overall Upper Bound for Spends",
+                            value = 50.0,
+                            key = "overall_upper_bound",
+                            # on_change=partial(update_data_bound_max_overall)
+                        )
+                min_value = round(_scenario.actual_total_spends *  (1-overall_lower_bound/100))
+                max_value = round(_scenario.actual_total_spends  * (1-overall_upper_bound/100))
                 with _columns2[0]:
                     spend_input = st.text_input(
                         "Absolute",
@@ -1406,35 +1595,21 @@ if auth_status == True:
                         # label_visibility="collapsed",
                         on_change=update_all_spends_abs,
                     )
-
+                # overall_lower_bound = 50.0
+                # overall_upper_bound = 50.0
                 with _columns2[1]:
                     st.number_input(
                         "Percent Change",
                         key="total_spends_change",
-                        min_value=-50.00,
-                        max_value=50.00,
-                        step=1.00,
+                        min_value= -1*overall_lower_bound,
+                        max_value= overall_upper_bound,
+                        step=0.01,
                         value=0.00,
                         on_change=update_spends,
                     )
 
-                with _columns2[2]:
-                    overall_lower_bound = st.number_input(
-                            "Overall Lower Bound for Spends",
-                            value = 50
-                            # key = overall_lower_bound,
-                            # on_change=partial(update_data_bound_min_overall)
-                        )
-                with _columns2[3]:
-                    overall_upper_bound = st.number_input(
-                            "Overall Upper Bound for Spends",
-                            value = 50
-                            # key = overall_upper_bound,
-                            # on_change=partial(update_data_bound_max_overall)
-                        )
-
-                    min_value = round(_scenario.actual_total_spends *  (1-overall_lower_bound/100))
-                    max_value = round(_scenario.actual_total_spends  * (1-overall_upper_bound/100))
+                
+                    
                     st.session_state["total_spends_change_abs_slider_options"] = [
                         numerize(value, 1)
                         for value in range(min_value, max_value + 1, int(1e4))
@@ -1462,7 +1637,7 @@ if auth_status == True:
                         key="total_sales_change",
                         min_value=-50.00,
                         max_value=50.00,
-                        step=1.00,
+                        step=0.01,
                         
                         value=0.00,
                         on_change=update_sales,
@@ -1578,8 +1753,9 @@ if auth_status == True:
                     # st.write(channel_spends)
                     # st.write(min_value)
                     # st.write(max_value)
-                    ### print(st.session_state[channel_name])
-
+                    ### # print(st.session_state[channel_name])
+                    # st.write(_channel_class.channel_bounds_min,channel_bounds_min)
+                    # st.write(_channel_class.channel_bounds_max,channel_bounds_max)
                     _columns_min = st.columns(2)
                     with _columns_min[0]:
                         spend_input = st.text_input(
@@ -1587,6 +1763,7 @@ if auth_status == True:
                             key=channel_name,
                             # label_visibility="collapsed",
                             on_change=partial(update_data, channel_name),
+
                         )
                         channel_name_lower_bound = f"{channel_name}_lower_bound"
                         
@@ -1613,7 +1790,7 @@ if auth_status == True:
                         channel_name_upper_bound = f"{channel_name}_upper_bound"
 
                         if channel_name_upper_bound not in st.session_state:
-                            st.session_state[channel_name_upper_bound] = str(10)
+                            st.session_state[channel_name_upper_bound] = str(100)
 
                         channel_bounds_max = st.text_input(
                             "Upper Bound Percentage",
@@ -1842,7 +2019,7 @@ if auth_status == True:
                 #     current_channel_spends,
                 # )
 
-                # # print(st.session_state["acutual_predicted"])
+                # # # print(st.session_state["acutual_predicted"])
                 summary_df = pd.DataFrame(st.session_state["acutual_predicted"])
                 # st.dataframe(summary_df)
                 summary_df.drop_duplicates(subset="Channel_name", keep="last", inplace=True)
@@ -2085,6 +2262,36 @@ if auth_status == True:
             disabled=len(st.session_state["scenario_input"]) == 0,#use_container_width=True
             
         )
+        # def prepare_download_func():
+
+        #     fig1,fig2,fig3 = scenario_planner_plots()
+
+        #     ppt_file =  save_ppt_file(summary_df_sorted,fig1,fig2,fig3)
+
+        if st.button("Prepare Analysis Download"):
+            fig1,fig2,fig3 = scenario_planner_plots2()
+            ppt_file = save_ppt_file(summary_df_sorted,fig1,fig2,fig3)
+            # Add a download button
+            try:
+                # ppt_file = prepare_download_func()
+                st.download_button(
+                    label="Download Response Curves And Optimised Spends Overview",
+                    data=ppt_file,
+                    file_name="MMM_Scenario_Planner_Presentation.pptx",
+                    mime="application/vnd.openxmlformats-officedocument.presentationml.presentation",
+                )
+            except:
+                st.write("")
+            # ppt_file =  save_ppt_file()
+            #     # Add a download button
+            # st.download_button(
+            #         label="Download Analysis",
+            #         data=ppt_file,
+            #         file_name="MMM_Model_Quality_Presentation.pptx",
+            #         mime="application/vnd.openxmlformats-officedocument.presentationml.presentation"
+            #     )
+    
+        
         
 
 
@@ -2108,3 +2315,5 @@ if auth_status != True:
                 st.error("Username not found")
     except Exception as e:
         st.error(e)
+
+    

pages/3_Saved_Scenarios.py

@@ -16,6 +16,11 @@ from yaml import SafeLoader
 from classes import class_from_dict
 import plotly.graph_objects as go
 
+from pptx import Presentation
+from pptx.util import Inches
+from io import BytesIO
+import plotly.io as pio
+
 st.set_page_config(layout='wide')
 load_local_css('styles.css')
 set_header()
@@ -24,6 +29,9 @@ st.title("Saved Scenarios")
 # 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 comparison_scenarios_df():
     
     ## create summary page
@@ -32,7 +40,7 @@ def comparison_scenarios_df():
     summary_df_spend = None
     summary_df_prospect = None
     # summary_df_efficiency = None
-    #=# print(scenarios_to_download)
+    #=# # print(scenarios_to_download)
     for scenario_name in scenarios_to_compare:
         scenario_dict =  st.session_state['saved_scenarios'][scenario_name]
         _spends = []
@@ -96,14 +104,65 @@ def comparison_scenarios_df():
         efficiency_df[c] = efficiency_df[c].round(2)
         
     return summary_df_spend,summary_df_prospect,efficiency_df
-
-
-
-def plot_comparison_chart(df,metric):
+import matplotlib.colors as mcolors
+import plotly.colors as pc
+
+def rgb_to_hex(rgb):
+    """Convert RGB tuple to hex color."""
+    return mcolors.to_hex(rgb)
+
+def generate_color_gradient(start_color, end_color, num_colors):
+    """Generate a list of hex color codes transitioning from start_color to end_color."""
+    if num_colors == 1:
+        return [start_color]
+    # Define the color scale from start to end color using hex codes
+    colorscale = [[0, start_color], [1, end_color]]
     
+    # Generate the colors
+    colors = pc.sample_colorscale(
+        colorscale,
+        [i / (num_colors - 1) for i in range(num_colors)],
+        colortype='hex'  # Use 'rgb' to get colors in RGB format
+    )
+    
+    # print(colors)
+    # Convert RGB tuples to hex
+    # hex_colors = [rgb_to_hex(color) for color in colors]
+    return colors
+
+# def generate_color_gradient(start_color, end_color, num_colors):
+#     import plotly.express as px
+#     """Generate a list of hex color codes transitioning from start_color to end_color."""
+#     colors = px.colors.sequential.Plasma  # Using a built-in color scale
+#     custom_colors = px.colors.sample_colorscale(
+#         colorscale=[[0, start_color], [1, end_color]],
+#         n_colors=num_colors
+#     )
+#     return custom_colors
+
+def plot_comparison_chart(df,metric,custom_colors):
+    # print(metric)
+    # print(custom_colors)
+    custom_colors = [
+        "#4169E1",  # Royal Blue
+    "#ADD8E6",  # Light Blue
+    "#FF7F50" ,  # Coral
+    "#87CEEB",  # Sky Blue
+    "#FA8072",  # Salmon
+    "#1E90FF",  # Dodger Blue
+    
+    "#00008B"  ,
+    "#F08080",  # Light Coral
+    
+    "#FF8C00",  # Dark Orange
+    "#FFA500",  # Orange
+    
+    ]
     # Create traces for each column
     traces = []
-    for column in df.columns:
+    for i,column in enumerate(df.columns):
+        # print(i)
+        # print(custom_colors[i])
         traces.append(go.Bar(
             x=df.index,
             y=df[column],
@@ -111,6 +170,7 @@ def plot_comparison_chart(df,metric):
             text=df[column].apply(numerize),  # Adding text for each point
             textposition='auto', 
             hoverinfo='x+y+text',
+            marker_color = custom_colors[i]
         ))
 
     # Create the layout
@@ -124,16 +184,79 @@ def plot_comparison_chart(df,metric):
     # Create the figure
     fig = go.Figure(data=traces, layout=layout)
 
+    fig.update_layout(
+
+    legend=dict(
+        orientation="h",  # Horizontal orientation
+        yanchor="top",    # Anchor the legend at the top
+        y=-0.45,           # Position the legend below the plot area
+        xanchor="center", # Center the legend horizontally
+        x=0.5            # Center the legend on the x-axis
+    )
+    )
+
     return fig
 
+def save_ppt_file(fig1,fig2,fig3):
+
+    # Initialize PowerPoint presentation
+    prs = Presentation()
+    # Helper function to add Plotly figure to slide
+    def add_plotly_chart_to_slide(slide, fig, left, top, width, height):
+        img_stream = BytesIO()
+        pio.write_image(fig, img_stream, format='png',engine="orca")
+        slide.shapes.add_picture(img_stream, left, top, width, height)
+
+    slide_1 = prs.slides.add_slide(prs.slide_layouts[6])
+    # title_1 = slide_1.shapes.title
+    # title_1.text = "Comparing Spends"
+    
+    add_plotly_chart_to_slide(slide_1, fig1, Inches(0), Inches(0.25), width=Inches(10), height=Inches(6))
+    
+    slide_2 = prs.slides.add_slide(prs.slide_layouts[6])
+    # title_2 = slide_2.shapes.title
+    # title_2.text = "Comparing Contributions"
+    add_plotly_chart_to_slide(slide_2, fig2, Inches(0), Inches(0.25), width=Inches(10), height=Inches(6))
+    
+
+    slide_3 = prs.slides.add_slide(prs.slide_layouts[6])
+    # title_3 = slide_3.shapes.title
+    # title_3.text = "Comparing Efficiency"
+    add_plotly_chart_to_slide(slide_3, fig3, Inches(0), Inches(0.25), width=Inches(10), height=Inches(6))
+    
+    ppt_stream = BytesIO()
+    prs.save(ppt_stream)
+    ppt_stream.seek(0)
+    
+    return ppt_stream.getvalue() 
+
 def create_comparison_plots():
     # comparison_scenarios_df()
     spends_df, prospects_df, efficiency_df = comparison_scenarios_df()
     # st.dataframe(spends_df)
-    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)
-    st.plotly_chart(plot_comparison_chart(efficiency_df,"Efficiency"),use_container_width=True)
+    blue = "#0000FF"  # Blue
+    green = "#00FF00" # Green
+    red = "#FF0000"   # Red
+
+    custom_colors = generate_color_gradient(blue, red, spends_df.shape[1])
+    st.plotly_chart(plot_comparison_chart(spends_df,"Spends",custom_colors),use_container_width=True)
+    st.plotly_chart(plot_comparison_chart(prospects_df,"Contributions",custom_colors),use_container_width=True)
+    st.plotly_chart(plot_comparison_chart(efficiency_df,"Efficiency",custom_colors),use_container_width=True)
     
+    fig1 = plot_comparison_chart(spends_df,"Spends",custom_colors)
+    fig2 = plot_comparison_chart(prospects_df,"Contributions",custom_colors)
+    fig3 = plot_comparison_chart(efficiency_df,"Efficiency",custom_colors)
+
+    ppt_file = save_ppt_file(fig1,fig2,fig3)
+    # Add a download button
+    st.download_button(
+        label="Download Comparision Analysis",
+        data=ppt_file,
+        file_name="MMM_Scenario_Comparision.pptx",
+        mime="application/vnd.openxmlformats-officedocument.presentationml.presentation"
+    )
+
+
 def create_scenario_summary(scenario_dict):
     summary_rows = []
     actual_total_spends = scenario_dict.get('actual_total_spends'), 
@@ -295,7 +418,7 @@ def download_scenarios():
     wb.remove(wb.active)
     st.session_state['xlsx_buffer'] = io.BytesIO()
     summary_df = None
-    ## print(scenarios_to_download)
+    ## # print(scenarios_to_download)
     for scenario_name in scenarios_to_download:
         scenario_dict =  st.session_state['saved_scenarios'][scenario_name]
         _spends = []
@@ -385,7 +508,7 @@ 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")
+        ## # print("Scenario page state reloaded")
         initialize_data(target_file = "Overview_data_test_panel@#prospects.xlsx")
 
 

response_curves_model_quality.py

@@ -112,7 +112,7 @@ def data_output(channel,X,y,y_fit_inv,x_ext_data,y_fit_inv_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)
+#     # # 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
@@ -125,7 +125,7 @@ def data_output(channel,X,y,y_fit_inv,x_ext_data,y_fit_inv_ext):
 
     ext_df['MAT'] = ["ext","ext","ext"]
     
-    # # print(ext_df)
+    # # # print(ext_df)
     plot_df= plot_df.append(ext_df)
     return plot_df
 
@@ -148,7 +148,7 @@ def input_data(df,spend_col,prospect_col):
     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)
+    # # # 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]
@@ -157,7 +157,7 @@ def extend_s_curve(x_max,x_minmax,y_minmax, Kd_fit, n_fit):
     for i in range(len(x_scaled)):
         x_data.append(x_scaled[i][0])
         
-    # # print(x_data)
+    # # # 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))
     
@@ -170,8 +170,8 @@ def fit_data(spend_col,prospect_col,channel):
 
     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)
+    # # # 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)
@@ -183,7 +183,7 @@ plotly_data = fit_data(spend_cols[0],prospect_cols[0],channel_cols[0])
 plotly_data.tail()
 
 for i in range(1,13):
-    # # print(i)
+    # # # 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")
     
@@ -211,7 +211,7 @@ def response_curves(channel,x_modified,y_modified):
     
     plotly_data2 = plotly_data.copy()
     plotly_data2 = plotly_data[plotly_data[x_col].isnull()==False]
-    print(plotly_data[plotly_data2['Date'] == plotly_data2['Date'].max()][x_col])
+    # print(plotly_data[plotly_data2['Date'] == plotly_data2['Date'].max()][x_col])
     # .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],
@@ -358,7 +358,7 @@ def data_output(channel,X,y,y_fit_inv,x_ext_data,y_fit_inv_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)
+#     # # 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
@@ -371,7 +371,7 @@ def data_output(channel,X,y,y_fit_inv,x_ext_data,y_fit_inv_ext):
 
     ext_df['MAT'] = ["ext","ext","ext"]
     
-    # # print(ext_df)
+    # # # print(ext_df)
     plot_df= plot_df.append(ext_df)
     return plot_df
 
@@ -394,7 +394,7 @@ def input_data(df,spend_col,prospect_col):
     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)
+    # # # 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]
@@ -403,7 +403,7 @@ def extend_s_curve(x_max,x_minmax,y_minmax, Kd_fit, n_fit):
     for i in range(len(x_scaled)):
         x_data.append(x_scaled[i][0])
         
-    # # print(x_data)
+    # # # 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))
     
@@ -416,8 +416,8 @@ def fit_data(spend_col,prospect_col,channel):
 
     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)
+    # # # 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)
@@ -429,7 +429,7 @@ plotly_data = fit_data(spend_cols[0],prospect_cols[0],channel_cols[0])
 plotly_data.tail()
 
 for i in range(1,13):
-    # # print(i)
+    # # # 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")
     
@@ -440,7 +440,7 @@ def response_curves(channel,x_modified,y_modified):
 
     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],
@@ -455,7 +455,7 @@ def response_curves(channel,x_modified,y_modified):
         marker=dict(color = 'blue'),
         name=x_col.replace('_Spends', '')
     ))
-    
+    dividing_parameter = len(plotly_data1[plotly_data1[x_col].isnull()==False])
     plotly_data2 = plotly_data.copy()
     plotly_data2 = plotly_data[plotly_data[x_col].isnull()==False]
     plotly_data2 = plotly_data2[plotly_data2["MAT"]!="ext"]
@@ -471,9 +471,10 @@ def response_curves(channel,x_modified,y_modified):
         name="Current Spends"
     ))
 
+    # print(dividing_parameter)
     fig.add_trace(go.Scatter(
-        x=[x_modified],
-        y=[y_modified],
+        x=[x_modified/dividing_parameter],
+        y=[y_modified/dividing_parameter],
         mode='markers',
         marker=dict(
         size=13  # Adjust the size value to make the markers larger or smaller

response_curves_model_quality_base.py

@@ -111,7 +111,7 @@ def data_output(channel,X,y,y_fit_inv,x_ext_data,y_fit_inv_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)
+#     # # print(x_ext_data)
     ext_df = pd.DataFrame()
     ext_df[f'{channel}_Spends'] = x_ext_data
     ext_df[f'{channel}_Prospects'] = y_fit_inv_v2_ext
@@ -125,7 +125,7 @@ def data_output(channel,X,y,y_fit_inv,x_ext_data,y_fit_inv_ext):
 
     ext_df['MAT'] = ["ext","ext","ext"]
     
-    # # print(ext_df.columns)
+    # # # print(ext_df.columns)
     plot_df= plot_df.append(ext_df)
     return plot_df
 
@@ -148,7 +148,7 @@ def input_data(df,spend_col,prospect_col):
     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)
+    # # # 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]
@@ -157,7 +157,7 @@ def extend_s_curve(x_max,x_minmax,y_minmax, Kd_fit, n_fit):
     for i in range(len(x_scaled)):
         x_data.append(x_scaled[i][0])
         
-    # # print(x_data)
+    # # # 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))
     
@@ -170,8 +170,8 @@ def fit_data(spend_col,prospect_col,channel):
 
     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)
+    # # # 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)
@@ -183,7 +183,7 @@ plotly_data = fit_data(spend_cols[0],prospect_cols[0],channel_cols[0])
 plotly_data.tail()
 
 for i in range(1,13):
-    # print(i)
+    # # 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")
     
@@ -213,6 +213,7 @@ def response_curves(channel,chart_typ):
             y=plotly_data.sort_values(by=x_col, ascending=True)[y_col],
             mode=mode_f1,
             name=x_col.replace('_Spends', '')
+            ,line=dict(color='#4B88FF')
         ))
     else:
         mode_f1 = "markers"
@@ -240,12 +241,13 @@ def response_curves(channel,chart_typ):
             y=plotly_data.sort_values(by=x_col, ascending=True)[y_col],
             mode=mode_f1,
             name=x_col.replace('_Spends', '')
+            ,line=dict(color='#4B88FF')
         ))
 
     
     plotly_data2 = plotly_data[plotly_data[x_col].isnull()==False]
     plotly_data2 = plotly_data2[plotly_data2["MAT"]!="ext"]
-    # print(plotly_data2[x_col].mean(),plotly_data2[y_col].mean())
+    # # print(plotly_data2[x_col].mean(),plotly_data2[y_col].mean())
     # import steamlit as st
     # st.dataframe()    
     fig.add_trace(go.Scatter(

summary_df.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:02f8f23713eadad9c91bae3af6649f9f2e7e2aa8d73fb28986bd48903cb74f38
+oid sha256:01b3193c6c809623ba5c8c76bb74b4583886310b8e7e7d4e35e17bdd63fa37d7
 size 1822

utilities.py

@@ -211,7 +211,7 @@ def initialize_data(
     # uopx_conv_rates = {'streaming_impressions' : 0.007,'digital_impressions' : 0.007,'search_clicks' : 0.00719,'tv_impressions' : 0.000173,
     #                    "digital_clicks":0.005,"streaming_clicks":0.004,'streaming_spends':1,"tv_spends":1,"search_spends":1,
     #                    "digital_spends":1}
-    # # print('State initialized')
+    # # # print('State initialized')
 
     excel = pd.read_excel(target_file, sheet_name=None)
 
@@ -305,16 +305,16 @@ def initialize_data(
         if updated_rcs is not None and updated_rcs_key in list(updated_rcs.keys()):
             response_curves[inp_col] = updated_rcs[updated_rcs_key]
 
-        # # print(response_curves)
+        # # # print(response_curves)
         ## conversion rates
         spend_col = [
             _col
             for _col in spend_df.columns
             if _col.startswith(inp_col.rsplit("_", 1)[0])
         ][0]
-        # # print(spend_col)
-        # # print('## printing spendssss')
-        # # print(spend_col)
+        # # # print(spend_col)
+        # # # print('## # printing spendssss')
+        # # # print(spend_col)
         conv = (
             spend_df.set_index("Week")[spend_col]
             / input_df.set_index("Date")[inp_col].clip(lower=1)
@@ -324,10 +324,10 @@ def initialize_data(
         conv_rates[inp_col] = list(conv.drop("Week", axis=1).mean().to_dict().values())[
             0
         ]
-        # # print(conv_rates)
-        ### print('Before',conv_rates[inp_col])
+        # # # print(conv_rates)
+        ### # print('Before',conv_rates[inp_col])
         # conv_rates[inp_col] = uopx_conv_rates[inp_col]
-        ### print('After',(conv_rates[inp_col]))
+        ### # print('After',(conv_rates[inp_col]))
 
         channel = Channel(
             name=inp_col,
@@ -347,21 +347,21 @@ def initialize_data(
                 "num_pos_obsv":param_dicts["num_pos_obsv"][inp_col]
             },
             bounds=np.array([-10, 10]),
-            channel_bounds_min = 10,
-            channel_bounds_max = 10
+            channel_bounds_min = round(param_dicts["x_min"][inp_col]*100*param_dicts["num_pos_obsv"][inp_col]/param_dicts["current_spends"][inp_col]),
+            channel_bounds_max = 100
         )
         channels[inp_col] = channel
         if sales is None:
             sales = channel.actual_sales
         else:
             sales += channel.actual_sales
-    # # print(actual_output_dic)
+    # # # print(actual_output_dic)
     other_contributions = (
         output_df.drop([*output_cols], axis=1).sum(axis=1, numeric_only=True).values
     )
     correction = output_df.drop("Date", axis=1).sum(axis=1).values - (sales + other_contributions)
-    # # print(other_contributions)
-    # # print(correction)
+    # # # print(other_contributions)
+    # # # print(correction)
     scenario = Scenario(
         name="default",
         channels=channels,

utilities_with_panel.py

@@ -98,7 +98,7 @@ DATA_PATH = './data'
 
 IMAGES_PATH = './data/images_224_224'
 
-# New - S# print 2
+# New - S# # print 2
 if 'bin_dict' not in st.session_state:
     
     with open("data_import.pkl", "rb") as f:
@@ -395,7 +395,7 @@ def initialize_data(target_col,selected_markets):
     # uopx_conv_rates = {'streaming_impressions' : 0.007,'digital_impressions' : 0.007,'search_clicks' : 0.00719,'tv_impressions' : 0.000173,
     #                    "digital_clicks":0.005,"streaming_clicks":0.004,'streaming_spends':1,"tv_spends":1,"search_spends":1,
     #                    "digital_spends":1}
-    ## print('State initialized')
+    ## # print('State initialized')
     # excel = pd.read_excel("data_test_overview_panel.xlsx",sheet_name=None)
     #excel = pd.read_excel("Overview_data_test_panel@#revenue.xlsx" + target_col + ".xlsx",sheet_name=None)
     
@@ -469,7 +469,7 @@ def initialize_data(target_col,selected_markets):
     for inp_col in channel_list:
         #st.write(inp_col)
 
-        # # New - S# print 2
+        # # New - S# # print 2
         # if is_panel:
         #     input_df1 = input_df.groupby([date_col]).agg({inp_col:'sum'}).reset_index() # aggregate spends on date
         #     spends = input_df1[inp_col].values
@@ -484,7 +484,7 @@ def initialize_data(target_col,selected_markets):
 
 
         # contribution
-        # New - S# print 2
+        # New - S# # print 2
         out_col = [_col for _col in output_df.columns if _col.startswith(inp_col)][0]
         if is_panel :
             output_df1 = output_df.groupby([date_col]).agg({out_col:'sum'}).reset_index()
@@ -505,12 +505,12 @@ def initialize_data(target_col,selected_markets):
             
         x = x.astype('float64')
         y = y.astype('float64')
-        ## print('## printing yyyyyyyyy')
-        ## print(inp_col)
-        ## print(x.max())
-        ## print(y.max())
+        ## # print('## # printing yyyyyyyyy')
+        ## # print(inp_col)
+        ## # print(x.max())
+        ## # print(y.max())
         # st.write(y.max(),x.max())
-        # print(y.max(),x.max())
+        # # print(y.max(),x.max())
         if y.max()<=0.01:
             if x.max()<=0.01 :
                 st.write("here-here")
@@ -539,15 +539,15 @@ def initialize_data(target_col,selected_markets):
         ## conversion rates
         spend_col = [_col for _col in spend_df.columns if _col.startswith(inp_col.rsplit('_',1)[0])][0]
 
-        ## print('## printing spendssss')
-        ## print(spend_col)
+        ## # print('## # printing spendssss')
+        ## # print(spend_col)
         conv = (spend_df.set_index('Week')[spend_col] / input_df.set_index('Date')[inp_col].clip(lower=1)).reset_index()
         conv.rename(columns={'index':'Week'},inplace=True)
         conv['year'] = conv.Week.dt.year
         conv_rates[inp_col] = list(conv.drop('Week',axis=1).mean().to_dict().values())[0]
-        ### print('Before',conv_rates[inp_col])
+        ### # print('Before',conv_rates[inp_col])
         # conv_rates[inp_col] = uopx_conv_rates[inp_col]
-        ### print('After',(conv_rates[inp_col]))
+        ### # print('After',(conv_rates[inp_col]))
         
         
         channel = Channel(name=inp_col,dates=dates,
@@ -617,7 +617,7 @@ def initialize_data(target_col,selected_markets):
 #     channel_list = []
 #     for col in raw_df.columns:
 #         if 'click' in col.lower() or 'spend' in col.lower() or 'imp' in col.lower():
-#             ### print(col)
+#             ### # print(col)
 #             channel_list.append(col)
 #         else:
 #             pass
@@ -708,7 +708,7 @@ def create_channel_summary(scenario):
         if name_mod.lower().endswith(' imp'):
             name_mod = name_mod.replace('Imp', ' Impressions')
 
-        # print(name_mod, channel.actual_total_spends, channel.conversion_rate,
+        # # print(name_mod, channel.actual_total_spends, channel.conversion_rate,
         channel.actual_total_spends * channel.conversion_rate
 
         summary_columns.append(name_mod)