Model_Result_Overview.py

import streamlit as st
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
import pickle
import Streamlit_functions as sf
from utilities import (load_authenticator)

from utilities_with_panel import (set_header,
                                  overview_test_data_prep_panel,
                                  overview_test_data_prep_nonpanel,
                                  initialize_data,
                                  load_local_css,
                                  create_channel_summary,
                                  create_contribution_pie,
                                  create_contribuion_stacked_plot,
                                  create_channel_spends_sales_plot,
                                  format_numbers,
                                  channel_name_formating)

import plotly.graph_objects as go
import streamlit_authenticator as stauth
import yaml
from yaml import SafeLoader
import time
from datetime import datetime,timedelta

st.set_page_config(layout='wide')
load_local_css('styles.css')
set_header()

st.title("Model Result Overview")

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')
        intercept = mdf.random_effects[market].values[0]
        random_eff_df.loc[i, 'random_effect'] = intercept
        random_eff_df.loc[i, panel_col] = market

    return random_eff_df


def process_train_and_test(train, test, features, panel_col, target_col):
    X1 = train[features]

    ss = MinMaxScaler()
    X1 = pd.DataFrame(ss.fit_transform(X1), columns=X1.columns)

    X1[panel_col] = train[panel_col]
    X1[target_col] = train[target_col]

    if test is not None:
        X2 = test[features]
        X2 = pd.DataFrame(ss.transform(X2), columns=X2.columns)
        X2[panel_col] = test[panel_col]
        X2[target_col] = test[target_col]
        return X1, X2
    return X1

def mdf_predict(X_df, mdf, random_eff_df) :
    X=X_df.copy()
    X=pd.merge(X, random_eff_df[[panel_col,'random_effect']], on=panel_col, how='left')
    X['pred_fixed_effect'] = mdf.predict(X)

    X['pred'] = X['pred_fixed_effect'] + X['random_effect']
    X.to_csv('Test/merged_df_contri.csv',index=False)
    X.drop(columns=['pred_fixed_effect', 'random_effect'], inplace=True)

    return X


target_col='Prospects'
target='Prospects'

# is_panel=False
# is_panel = st.session_state['is_panel']
#panel_col = [col.lower().replace('.','_').replace('@','_').replace(" ", "_").replace('-', '').replace(':', '').replace("__", "_") for col in  st.session_state['bin_dict']['Panel Level 1']  ] [0]# set the panel column
panel_col='Panel'
date_col = 'date'

#st.write(media_data)

is_panel = True 

# panel_col='markets'
date_col = 'date'
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

authenticator = st.session_state.get('authenticator')

if authenticator is None:
    authenticator = load_authenticator()
    
name, authentication_status, username = authenticator.login('Login', 'main')
auth_status = st.session_state['authentication_status']

if auth_status:
    authenticator.logout('Logout', 'main')
    
    is_state_initiaized = st.session_state.get('initialized',False)
    if not is_state_initiaized:
        a=1
    
    with st.expander("View Channel Wise Spend And Prospect Analysis "):
        # Create two columns for start date and end date input
        col1, col2 = st.columns(2) 
        min_date,max_date = sf.get_date_range()
        # st.write(min_date,max_date)
        # min_date = datetime(2023, 1, 1)
        # max_date = datetime(2024, 12, 31)
        default_date1,default_date2 = sf.get_default_dates()   
        # st.write(default_date1,default_date2)                                                       
        with col1:
            start_date = st.date_input("Start Date: ",value=default_date1,min_value=min_date,
                                        max_value=max_date)
        with col2:
            end_date = st.date_input("End Date: ",value = default_date2,min_value=min_date,
                                        max_value=max_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)

         ## 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)
        # Format first three rows in percentage format
        # styled_df = sf.shares_table_func(shares_df)
        # # styled_df = styled_df.round(0).astype(int)
        # styled_df.iloc[:3] = (styled_df.iloc[:3]).astype(int)

            # # Round next two rows to two decimal places
            # styled_df.iloc[3:5] = styled_df.iloc[3:5].round(0).astype(str)

            # st.table(styled_df)
        shares_df = sf.shares_df_func(start_date,end_date)
        st.dataframe(sf.shares_table_func(shares_df),use_container_width=True)
        
        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
    with st.expander("View Change in MMM Estimated Prospect Contributions Analysis"):
        # 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":
            options = [
                "Month on Month",
                "Year on Year"]
            col1, col2 = st.columns(2)
                # Create a dropdown menu
            with col1:
                selected_option = st.selectbox('Select a comparison', options)
            with col2:
                st.markdown("""</br>""",unsafe_allow_html=True)
                if selected_option == "Month on Month" :

                    st.markdown(
                        f"""
                        <div style="padding: 5px; border-radius: 5px; background-color: #FFFFE0; width: fit-content; display: inline-block;">
                            <strong> Comparision of current month spends to previous month spends</strong>
                        </div>
                        """,
                        unsafe_allow_html=True
                    )
                else :
                    st.markdown(
                        f"""
                        <div style="padding: 5px; border-radius: 5px; background-color: #FFFFE0; width: fit-content; display: inline-block;">
                            <strong> Comparision of current month spends to the same month in previous year</strong>
                        </div>
                        """,
                        unsafe_allow_html=True
                    )
                # Waterfall chart
            
            def get_month_year_list(start_date, end_date):
                # Generate a range of dates from start_date to end_date with a monthly frequency
                dates = pd.date_range(start=start_date, end=end_date, freq='MS')  # 'MS' is month start frequency
                
                # Extract month and year from each date and create a list of tuples
                month_year_list = [(date.month, date.year) for date in dates]
                
                return month_year_list
            def get_start_end_dates(month, year):
                start_date = datetime(year, month, 1).date()
                
                if month == 12:
                    end_date = datetime(year + 1, 1, 1).date() - timedelta(days=1)
                else:
                    end_date = datetime(year, month + 1, 1).date() - timedelta(days=1)
                
                return start_date, end_date
            
            month_year_list = get_month_year_list(start_date, end_date)
            dropdown_options = [f"{date.strftime('%B %Y')}" for date in pd.date_range(start=start_date, end=end_date, freq='MS')]
            waterfall_option = st.selectbox("Select a month:", dropdown_options)
            waterfall_date = datetime.strptime(waterfall_option, "%B %Y")
            waterfall_month = waterfall_date.month 
            waterfall_year = waterfall_date.year 
            waterfall_start_date, waterfall_end_date = get_start_end_dates(waterfall_month, waterfall_year)
            # st.write("abc")
            # figw = sf.waterfall(waterfall_start_date,waterfall_end_date)
            figw= sf.waterfall(waterfall_start_date,waterfall_end_date,selected_option)
            st.plotly_chart(figw,use_container_width=True)

        elif data_selection_type == "Compare Custom Range": 
            col1, col2 = st.columns(2)
            min_date,max_date = sf.get_date_range() 
            with col1:
                st.write("Select Time Period 1")
                sc1,sc2 = st.columns(2)
                with sc1:
                    waterfall_start_date1 = st.date_input("Start Date 1: ",value=start_date,min_value=min_date,
                                            max_value=max_date)
                with sc2:
                    waterfall_end_date1 = st.date_input("End Date 1: ",value = end_date,min_value=min_date,
                                            max_value=max_date)
            with col2:
                st.write("Select Time Period 2")
                ec1,ec2 = st.columns(2)
                with ec1:
                    waterfall_start_date2 = st.date_input("Start Date 2: ",value=end_date-timedelta(days = -1),min_value=min_date,
                                            max_value=max_date)
                with ec2:
                    diff = min((start_date-end_date).days,-30)
                    waterfall_end_date2 = st.date_input("End Date 2: ",value = start_date,min_value=min_date,
                                            max_value=max_date)
            try:
                figw= sf.waterfall2(waterfall_start_date1,waterfall_end_date1,waterfall_start_date2,waterfall_end_date2)
                st.plotly_chart(figw,use_container_width=True)
            except:
                st.warning("Previous data does not exist")



        # Waterfall table
        # shares_df = sf.shares_df_func(waterfall_start_date,waterfall_end_date)
        st.table(sf.waterfall_table_func(shares_df).style.format("{:.0%}"))

   
    with st.expander("View Decomposition Analysis"):    
        ### Base decomp CHART
        st.plotly_chart(sf.base_decomp(),use_container_width=True)

        ### Media decomp CHART
        st.plotly_chart(sf.media_decomp(),use_container_width=True)