File size: 7,816 Bytes
47e386b
bf40641
8cfb9bd
 
 
 
d96c1a5
558e91c
47e386b
 
 
 
 
f4a07f9
 
 
 
d96c1a5
 
8cfb9bd
d96c1a5
47e386b
 
 
 
 
 
 
 
 
95d5e6c
 
 
 
 
 
47e386b
8d0e96f
 
 
 
 
 
 
 
 
 
 
 
258d1fd
 
8d0e96f
 
 
 
 
 
47e386b
 
 
 
 
 
 
 
 
 
 
 
 
 
8d0e96f
9d880f3
f238172
258d1fd
 
f238172
dfadb49
 
 
 
 
 
 
 
f238172
47e386b
 
 
dfadb49
 
 
 
47e386b
 
 
 
95d5e6c
47e386b
 
d70ad07
 
dfadb49
d70ad07
90d5f4e
dfadb49
d70ad07
ecdc977
dfadb49
ecdc977
d70ad07
 
47e386b
d70ad07
dfadb49
47e386b
 
95d5e6c
47e386b
 
 
 
 
 
 
 
 
8cfb9bd
 
 
 
 
 
97994b8
8cfb9bd
 
df06091
dfadb49
3e07f55
 
dfadb49
3e07f55
 
97994b8
dfadb49
f4a07f9
 
46b4656
f4a07f9
707a69f
f4a07f9
 
707a69f
f4a07f9
 
 
 
47e386b
 
f4a07f9
 
47e386b
f4a07f9
707a69f
 
 
 
 
 
f4a07f9
707a69f
 
 
 
3d2f26f
707a69f
 
 
 
89f0ac5
47e386b
8cfb9bd
47e386b
 
707a69f
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
import streamlit as st
import pandas as pd
from app_config import AppConfig  # Import the configurations class
from data_processor import DataProcessor  # Import the data analysis class
from visualization import Visualization  # Import the data viz class
from ai_analysis import AIAnalysis  # Import the ai analysis class
from sidebar import Sidebar  # Import the Sidebar class
from report import ReportGenerator

def main():
    # Initialize the app configuration
    app_config = AppConfig()

    # Initialize the session state 
    if 'ai_recommendations' not in st.session_state:
        st.session_state.ai_recommendations = None

    # Initialize the sidebar
    sidebar = Sidebar()
    sidebar.display()

    # Initialize the data processor
    data_processor = DataProcessor()

    # Initialize the visualization handler
    visualization = Visualization()

    # Initialize the AI analysis handler
    ai_analysis = AIAnalysis(data_processor.client)

    st.title("Literacy Implementation Record Data Analysis")

    # Add the descriptive text
    st.markdown("""
    This tool summarizes implementation record data for student attendance, engagement, and intervention dosage to address hypothesis #1: Have Students Received Adequate Instruction?
    """)

    # Date selection option
    date_option = st.radio(
        "Select data range:",
        ("All Data", "Date Range")
    )

    # Initialize start and end date variables
    start_date = None
    end_date = None

    if date_option == "Date Range":
        # Prompt user to enter start and end dates
        start_date = st.date_input("Start Date")
        end_date = st.date_input("End Date")

        # Ensure start date is before end date
        if start_date > end_date:
            st.error("Start date must be before end date.")
            return

    # File uploader
    uploaded_file = st.file_uploader("Upload your Excel file", type=["xlsx"])

    if uploaded_file is not None:
        try:
            # Read the Excel file into a DataFrame
            df = data_processor.read_excel(uploaded_file)

            # Format the session data
            df = data_processor.format_session_data(df)

            # Replace student names with initials
            df = data_processor.replace_student_names_with_initials(df)

            # Filter data if date range is selected
            if date_option == "Date Range":
                # Convert start_date and end_date to datetime
                start_date = pd.to_datetime(start_date).date()
                end_date = pd.to_datetime(end_date).date()

                # Identify the date column
                date_column = next((col for col in df.columns if col in ["Date of Session", "Date"]), None)
                if date_column:
                    # Filter the DataFrame based on the selected date range
                    df = df[(df[date_column] >= start_date) & (df[date_column] <= end_date)]
                else:
                    st.error("Date column not found in the data.")
                    return

            st.subheader("Uploaded Data")
            st.write(df)

            # Ensure the intervention column is determined
            intervention_column = data_processor.get_intervention_column(df)
            if intervention_column not in df.columns:
                st.error(f"Expected column '{intervention_column}' not found.")
                return

            # Compute Intervention Session Statistics
            intervention_stats = data_processor.compute_intervention_statistics(df)
            st.subheader("Intervention Dosage")
            st.write(intervention_stats)

            # Plot and download intervention statistics: Two-column layout for the visualization and intervention frequency
            col1, col2 = st.columns([3, 1])  # Set the column width ratio

            with col1:
                intervention_fig = visualization.plot_intervention_statistics(intervention_stats)

            with col2:
                intervention_frequency = intervention_stats['Intervention Dosage (%)'].values[0]
                # Display the "Intervention Dosage (%)" text
                st.markdown("<h3 style='color: #358E66;'>Intervention Dosage</h3>", unsafe_allow_html=True)
                # Display the frequency value below it
                st.markdown(f"<h1 style='color: #358E66;'>{intervention_frequency}%</h1>", unsafe_allow_html=True)

            visualization.download_chart(intervention_fig, "intervention_statistics_chart.png")

            # Compute Student Metrics
            student_metrics_df = data_processor.compute_student_metrics(df)
            st.subheader("Student Attendance and Engagement")
            st.write(student_metrics_df)

            # Compute Student Metric Averages
            attendance_avg_stats, engagement_avg_stats = data_processor.compute_average_metrics(student_metrics_df)

            # Plot and download student metrics
            student_metrics_fig = visualization.plot_student_metrics(student_metrics_df, attendance_avg_stats, engagement_avg_stats)
            visualization.download_chart(student_metrics_fig, "student_metrics_chart.png")

            # Evaluate each student and build decision tree diagrams
            student_metrics_df['Evaluation'] = student_metrics_df.apply(
                lambda row: data_processor.evaluate_student(row), axis=1
            )
            st.subheader("Student Evaluations")
            st.write(student_metrics_df[['Student', 'Evaluation']])

            # Build and display decision tree diagrams for each student
            for index, row in student_metrics_df.iterrows():
                tree_diagram = visualization.build_tree_diagram(row)

                # Get the student's name from the DataFrame
                student_name = row['Student']

                # Use st.expander to wrap the graphviz chart with the student's name
                with st.expander(f"{student_name} Decision Tree", expanded=False):
                    st.graphviz_chart(tree_diagram.source)

            # Generate Notes and Recommendations using LLM
            if st.session_state.ai_recommendations is None:
                with st.spinner("Generating MTSS.ai Analysis..."):
                    llm_input = ai_analysis.prepare_llm_input(student_metrics_df)
                    # recommendations = ai_analysis.prompt_response_from_hf_llm(llm_input)
                    recommendations = ai_analysis.prompt_response_from_mistral_llm(llm_input)
                    st.session_state.ai_recommendations = recommendations
            
            # Display the recommendations
            st.subheader("MTSS.ai Analysis")
            # st.markdown(recommendations)
            st.markdown(st.session_state.ai_recommendations)

            # Download AI output
            # ai_analysis.download_llm_output(recommendations, "MTSSai_Report.txt")
            ai_analysis.download_llm_output(st.session_state.ai_recommendations, "MTSSai_Report.txt")

            # Generate the PDF Report using the stored recommendations
            report_gen = ReportGenerator()
            combined_pdf = report_gen.create_combined_pdf(
                intervention_fig, 
                student_metrics_fig, 
                st.session_state.ai_recommendations
            )
                
            # Add the download button for the PDF
            st.download_button(
                label="Download MTSS.ai Report (PDF)",
                data=combined_pdf,
                file_name="MTSSai_LIR_Report.pdf",
                mime="application/pdf",
                icon="📄", 
                use_container_width=True
            )

        except Exception as e:
            st.error(f"Error processing the file: {str(e)}")

if __name__ == '__main__':
    main()