app.py

import streamlit as st
import pandas as pd
import numpy as np
import plotly.express as px
from scipy.stats import norm

# Define your helper functions
def is_matching_pattern(column, prefix):
    if not column.startswith(prefix + '_'):
        return False
    suffix = column[len(prefix) + 1:]
    if 1 <= len(suffix) <= 3 and suffix.isdigit():
        return True
    return False

def multi_answer(df):
    frequency = {}
    for i in df.columns:
        unique_values = list(set(df[i].dropna()))[0]
        frequency[str(unique_values)] = df[i].value_counts().get(unique_values, 0)

    frequency_dataframe = pd.DataFrame({
        "Value": frequency.keys(),
        "Frequency": frequency.values(),
        "Percentile": np.array(list(frequency.values())) / len(df.dropna(how='all'))
    }).sort_values(by='Value')
    frequency_dataframe.loc[len(frequency_dataframe)] = ['Sample_size', len(df.dropna(how='all')), 1]
    return frequency_dataframe

def single_answer(df):
    counter = df.value_counts()
    frequency_dataframe = pd.DataFrame({
        'Value': counter.index,
        'Frequency': counter.values,
        'Percentage': (counter.values / counter.sum()) * 100
    }).sort_values(by='Value')
    frequency_dataframe.loc[len(frequency_dataframe)] = ['Sample_size', len(df.dropna()), 1]
    return frequency_dataframe

def two_variable_ss(df, var1, var2):
    counter = df.groupby(var1)[var2].value_counts()
    frequency_dataframe = counter.unstack(fill_value=0)

    column_sums = frequency_dataframe.sum(axis=0)
    percentile_dataframe = frequency_dataframe.div(column_sums, axis=1)

    frequency_dataframe.loc['Sample_size'] = list(single_answer(df[var2]).iloc[:,1])[:-1]
    frequency_dataframe['Sample_size'] = list(single_answer(df[var1]).iloc[:,1])

    return percentile_dataframe, frequency_dataframe

# Functions related to Z-Test
def read_excel_sheets(file):
    """Reads an Excel file with multiple sheets and returns a dictionary of DataFrames."""
    try:
        xls = pd.ExcelFile(file)
        sheets_data = {sheet: xls.parse(sheet) for sheet in xls.sheet_names}
        return sheets_data
    except Exception as e:
        st.error(f"❌ Error reading Excel file: {e}")
        return None

def z_testes(n1, n2, p1, p2):
    """Performs Z-test for proportions and returns p-value."""
    try:
        pooled_p = (n1 * p1 + n2 * p2) / (n1 + n2)
        se = np.sqrt(pooled_p * (1 - pooled_p) * (1 / n1 + 1 / n2))
        z = (p1 - p2) / se
        p_value = 2 * (1 - norm.cdf(abs(z)))
        return p_value
    except ZeroDivisionError:
        return np.nan

def Z_test_dataframes(sheets_data):
    """Processes each sheet's DataFrame and computes new DataFrames with Z-test results."""
    result_dataframes = {}
    for sheet_name, df in sheets_data.items():
        if df.empty:
            st.warning(f"⚠️ Sheet '{sheet_name}' is empty and has been skipped.")
            continue
        df = df.set_index(df.columns[0])  # Use the first column as index
        rows, cols = df.shape
        if cols < 2:
            st.warning(f"⚠️ Sheet '{sheet_name}' does not have enough columns for analysis and has been skipped.")
            continue
        new_df = pd.DataFrame(index=df.index[:-1], columns=df.columns[1:])
        for i, row_name in enumerate(df.index[:-1]):
            for j, col_name in enumerate(df.columns[1:]):
                try:
                    n1 = df.iloc[-1, 0]  # x_I1
                    n2 = df.iloc[-1, j+1]  # x_Ij
                    p1 = df.iloc[i, 0]  # x_1J
                    p2 = df.iloc[i, j+1]  # x_ij
                    p_value = z_testes(n1, n2, p1, p2)
                    new_df.iloc[i, j] = p_value
                except Exception as e:
                    st.error(f"❌ Error processing sheet '{sheet_name}', row '{row_name}', column '{col_name}': {e}")
                    new_df.iloc[i, j] = np.nan

        result_dataframes[sheet_name] = new_df

    return result_dataframes

def analyze_z_test(file):
    """
    Performs Z-Test analysis on the uploaded Excel file.

    Parameters:
    - file: Uploaded Excel file

    Returns:
    - result_dataframes: Dictionary of DataFrames with p-values
    """
    sheets_data = read_excel_sheets(file)
    if sheets_data is None:
        return None

    result_dataframes = Z_test_dataframes(sheets_data)

    if not result_dataframes:
        st.error("❌ No valid sheets found for Z-Test analysis.")
        return None

    st.write("### 📈 Processed Tables with Z-Test Results")
    for sheet_name, df in result_dataframes.items():
        st.write(f"#### Sheet: {sheet_name}")
        
        # Apply color coding based on p-value
        def color_p_value(val):
            try:
                if pd.isna(val):
                    return 'background-color: lightgray'
                elif val < 0.05:
                    return 'background-color: lightgreen'
                else:
                    return 'background-color: lightcoral'
            except:
                return 'background-color: lightgray'
        
        styled_df = df.style.applymap(color_p_value)
        
        # Display the styled DataFrame
        st.dataframe(styled_df, use_container_width=True)
    
    return result_dataframes

# Streamlit User Interface
st.title("Data Analysis Application")

# Main options
main_option = st.selectbox("Please select an option:", ["Tabulation", "Hypothesis test", "Machine Learning", "Coding"])

if main_option == "Tabulation":
    st.header("Tabulation Analysis")
    uploaded_file = st.file_uploader("Please upload your Excel file", type=["xlsx", "xls"])
    if uploaded_file:
        try:
            df = pd.read_excel(uploaded_file)
            st.subheader("Displaying the first few rows of the DataFrame")
            st.dataframe(df.head())

            tabulation_option = st.selectbox("Please select the type of analysis:", ["All", "Univariate", "Multivariate"])

            if tabulation_option == "All":
                st.info("This section of the program is under development.")
            elif tabulation_option == "Univariate":
                uni_option = st.selectbox("Select the type of univariate analysis:", ["Multiple answer", "Single answer"])

                if uni_option == "Single answer":
                    var = st.text_input("Please enter the name of the desired column:")
                    if var:
                        if var in df.columns:
                            result_df = single_answer(df[var])
                            st.subheader("Univariate Analysis Results")
                            st.dataframe(result_df)

                            fig = px.bar(result_df, x='Value', y='Percentage', title='Percentage Histogram')
                            st.plotly_chart(fig, use_container_width=True)
                        else:
                            st.error("The entered column was not found.")
                elif uni_option == "Multiple answer":
                    var = st.text_input("Please enter the name of the desired column:")
                    if var:
                        matching_cols = [col for col in df.columns if is_matching_pattern(col, var)]
                        if matching_cols:
                            subset_df = df[matching_cols]
                            result_df = multi_answer(subset_df)
                            st.subheader("Multiple Answer Analysis Results")
                            st.dataframe(result_df)

                            fig = px.bar(result_df, x='Value', y='Percentile', title='Percentile Histogram')
                            st.plotly_chart(fig, use_container_width=True)
                        else:
                            st.error("No columns matching the entered pattern were found.")
            elif tabulation_option == "Multivariate":
                st.subheader("Multivariate Analysis")
                var1 = st.text_input("Please enter the name of the first column:")
                var2 = st.text_input("Please enter the name of the second column:")

                if var1 and var2:
                    if var1 in df.columns and var2 in df.columns:
                        type1 = st.selectbox("Select the type of analysis for the first column:", ["Multiple answer", "Single answer"], key='type1')
                        type2 = st.selectbox("Select the type of analysis for the second column:", ["Multiple answer", "Single answer"], key='type2')

                        if type1 == "Single answer" and type2 == "Single answer":
                            percentile_df, frequency_df = two_variable_ss(df[[var1, var2]], var1, var2)
                            st.subheader("Percentile Table")
                            st.dataframe(percentile_df)

                            st.subheader("Frequency Table")
                            st.dataframe(frequency_df)

                            fig = px.imshow(percentile_df, text_auto=True, title='Percentile Heatmap')
                            st.plotly_chart(fig, use_container_width=True)
                        else:
                            st.info("This section of the program is under development.")
                    else:
                        st.error("One or both of the entered columns were not found.")
        except Exception as e:
            st.error(f"❌ Error reading the Excel file: {e}")

elif main_option == "Hypothesis test":
    st.header("Hypothesis Testing")
    hypothesis_option = st.selectbox("Please select the type of hypothesis test:", ["Z test", "T test", "Chi-Square test", "ANOVA test"])

    if hypothesis_option != "Z test":
        st.info("This section of the program is under development.")
    else:
        uploaded_file = st.file_uploader("Please upload your Excel file for Z-Test", type=["xlsx", "xls"])
        if uploaded_file:
            result = analyze_z_test(uploaded_file)
            if result:
                st.success("Z-Test analysis completed successfully.")

elif main_option in ["Machine Learning", "Coding"]:
    st.info("This section of the program is under development.")