Spaces:
Runtime error
Runtime error
| import streamlit as st | |
| import numpy as np | |
| import scipy.stats as stats | |
| from fpdf import FPDF | |
| import base64 | |
| import os | |
| from plots import test_profile | |
| import matplotlib.pyplot as plt | |
| from PIL import Image | |
| test_dict = { | |
| "animal": { | |
| "low_age_low_education": { | |
| "mean": 21.0, | |
| "std": 7.0 | |
| }, "low_age_high_education": { | |
| "mean": 22.4, | |
| "std": 6.8 | |
| }, "high_age_low_education": { | |
| "mean": 22.1, | |
| "std": 5.7 | |
| }, "high_age_high_education": { | |
| "mean": 25.6, | |
| "std": 5.6 | |
| } | |
| }, "verb": { | |
| "low_age_low_education": { | |
| "mean": 17.6, | |
| "std": 4.3 | |
| }, "low_age_high_education": { | |
| "mean": 20.5, | |
| "std": 5.4 | |
| }, "high_age_low_education": { | |
| "mean": 16.7, | |
| "std": 6.1 | |
| }, "high_age_high_education": { | |
| "mean": 22.7, | |
| "std": 5.1 | |
| } | |
| }, "repetition": { | |
| "low_age_low_education": { | |
| "mean": 24.8, | |
| "std": 4.8 | |
| }, "low_age_high_education": { | |
| "mean": 25.9, | |
| "std": 3.7 | |
| }, "high_age_low_education": { | |
| "mean": 24.0, | |
| "std": 4.9 | |
| }, "high_age_high_education": { | |
| "mean": 25.8, | |
| "std": 3.8 | |
| } | |
| }, "months_backward": { | |
| "low_age_low_education": { | |
| "mean": 10.3, | |
| "std": 4.5 | |
| }, "low_age_high_education": { | |
| "mean": 9.8, | |
| "std": 3.2 | |
| }, "high_age_low_education": { | |
| "mean": 10.0, | |
| "std": 3.2 | |
| }, "high_age_high_education": { | |
| "mean": 9.9, | |
| "std": 3.5 | |
| } | |
| }, | |
| "logicogrammatic": { | |
| "low_age_low_education": { | |
| "mean": 27.2, | |
| "std": 3.8 | |
| }, "low_age_high_education": { | |
| "mean": 27.4, | |
| "std": 3.1 | |
| }, "high_age_low_education": { | |
| "mean": 23.5, | |
| "std": 4.2 | |
| }, "high_age_high_education": { | |
| "mean": 27.2, | |
| "std": 3.3 | |
| } | |
| },"inference": { | |
| "low_age_low_education": { | |
| "mean": 28.2, | |
| "std": 2.4 | |
| }, "low_age_high_education": { | |
| "mean": 28.4, | |
| "std": 2.8 | |
| }, "high_age_low_education": { | |
| "mean": 25.2, | |
| "std": 3.9 | |
| }, "high_age_high_education": { | |
| "mean": 27.3, | |
| "std": 2.9 | |
| } | |
| }, "reading_speed": { | |
| "low_age_low_education": { | |
| "mean": 21.5, | |
| "std": 5.4 | |
| }, "low_age_high_education": { | |
| "mean": 27.3, | |
| "std": 5.5 | |
| }, "high_age_low_education": { | |
| "mean": 23.0, | |
| "std": 7.2 | |
| }, "high_age_high_education": { | |
| "mean": 28.8, | |
| "std": 5.2 | |
| } | |
| }, "decoding_words": { | |
| "low_age_low_education": { | |
| "mean": 107.6, | |
| "std": 27.8 | |
| }, "low_age_high_education": { | |
| "mean": 112.9, | |
| "std": 22.7 | |
| }, "high_age_low_education": { | |
| "mean": 111.4, | |
| "std": 26.1 | |
| }, "high_age_high_education": { | |
| "mean": 122.9, | |
| "std": 28.2 | |
| } | |
| }, "decoding_non_words": { | |
| "low_age_low_education": { | |
| "mean": 95.8, | |
| "std": 26.6 | |
| }, "low_age_high_education": { | |
| "mean": 105.4, | |
| "std": 29.5 | |
| }, "high_age_low_education": { | |
| "mean": 103.4, | |
| "std": 25.2 | |
| }, "high_age_high_education": { | |
| "mean": 118.0, | |
| "std": 26.8 | |
| } | |
| }, | |
| # jönsson och winnerstam 2012 | |
| "pataka": { | |
| "low_age_low_education": { | |
| "mean": 5.8, | |
| "std": 1.0 | |
| }, "low_age_high_education": { | |
| "mean": 5.8, | |
| "std": 1.0 | |
| }, "high_age_low_education": { | |
| "mean": 5.8, | |
| "std": 1.0 | |
| }, "high_age_high_education": { | |
| "mean": 5.8, | |
| "std": 1.0 | |
| } | |
| } | |
| } | |
| # Function to calculate z-score | |
| def calculate_z_score(test_score, mean, std_dev): | |
| return (test_score - mean) / std_dev | |
| def z_score_calculator(value, norm_mean, norm_sd, invert=False): | |
| z_value = (value - norm_mean) / norm_sd | |
| if invert: | |
| z_value = -z_value | |
| stanine_value = zscore_to_stanine(z_value) | |
| z_score = round(z_value, 2) | |
| return z_score, stanine_value | |
| def zscore_to_stanine(zscore): | |
| if zscore <= -1.76: | |
| return 1 | |
| elif zscore <= -1.26: | |
| return 2 | |
| elif zscore <= -0.76: | |
| return 3 | |
| elif zscore <= -0.26: | |
| return 4 | |
| elif zscore <= 0.25: | |
| return 5 | |
| elif zscore <= 0.75: | |
| return 6 | |
| elif zscore <= 1.25: | |
| return 7 | |
| elif zscore <= 1.75: | |
| return 8 | |
| else: | |
| return 9 | |
| def test_calculator(age, education, values, test, invert=False): | |
| if age <= 60 and education <= 12: | |
| norm_mean = test_dict[test]["low_age_low_education"]["mean"] | |
| norm_sd = test_dict[test]["low_age_low_education"]["std"] | |
| z_score, stanine_value = z_score_calculator(values, norm_mean, norm_sd, invert=invert) | |
| return norm_mean, norm_sd, z_score, stanine_value | |
| elif age <= 60 and education > 12: | |
| norm_mean = test_dict[test]["low_age_high_education"]["mean"] | |
| norm_sd = test_dict[test]["low_age_high_education"]["std"] | |
| z_score, stanine_value = z_score_calculator(values, norm_mean, norm_sd, invert=invert) | |
| return norm_mean, norm_sd, z_score, stanine_value | |
| elif age > 60 and education <= 12: | |
| norm_mean = test_dict[test]["high_age_low_education"]["mean"] | |
| norm_sd = test_dict[test]["high_age_low_education"]["std"] | |
| z_score, stanine_value = z_score_calculator(values, norm_mean, norm_sd, invert=invert) | |
| return norm_mean, norm_sd, z_score, stanine_value | |
| elif age > 60 and education > 12: | |
| norm_mean = test_dict[test]["high_age_high_education"]["mean"] | |
| norm_sd = test_dict[test]["high_age_high_education"]["std"] | |
| z_score, stanine_value = z_score_calculator(values, norm_mean, norm_sd, invert=invert) | |
| return norm_mean, norm_sd, z_score, stanine_value | |
| else: | |
| print("missing value/ wrong format") | |
| def isw_calculator(age, education, isw): | |
| print("the isw is", isw) | |
| isw_score = 74.38 + isw*0.66 - age*0.20 + education*1.77 | |
| # round to nearest integer | |
| isw_score = round(isw_score) | |
| print("the score is: ", isw_score) | |
| isw_score_stanine = isw_stanine_calculator(isw_score) | |
| return 0, 0, isw_score, isw_score_stanine | |
| def isw_stanine_calculator(isw_score): | |
| print("the score is: ", isw_score) | |
| if isw_score <= 73: | |
| return 1 | |
| elif isw_score <= 81: | |
| return 2 | |
| elif isw_score <= 88: | |
| return 3 | |
| elif isw_score <= 96: | |
| return 4 | |
| elif isw_score <= 103: | |
| return 5 | |
| elif isw_score <= 111: | |
| return 6 | |
| elif isw_score <= 118: | |
| return 7 | |
| elif isw_score <= 126: | |
| return 8 | |
| elif isw_score >= 127: | |
| return 9 | |
| def bnt_calculator(age, education, bnt): | |
| if age <= 60 and education <= 12: | |
| norm_mean = 54.5 | |
| norm_sd = 3.2 | |
| z_score, stanine_value = z_score_calculator(bnt, norm_mean, norm_sd) | |
| return norm_mean, norm_sd, z_score, stanine_value | |
| elif age <= 60 and education > 12: | |
| norm_mean = 54.0 | |
| norm_sd = 4.4 | |
| z_score, stanine_value = z_score_calculator(bnt, norm_mean, norm_sd) | |
| return norm_mean, norm_sd, z_score, stanine_value | |
| elif age > 60 and education <= 12: | |
| norm_mean = 54.8 | |
| norm_sd = 3.3 | |
| z_score, stanine_value = z_score_calculator(bnt, norm_mean, norm_sd) | |
| return norm_mean, norm_sd, z_score, stanine_value | |
| elif age > 60 and education > 12: | |
| norm_mean = 56.2 | |
| norm_sd = 3.4 | |
| z_score, stanine_value = z_score_calculator(bnt, norm_mean, norm_sd) | |
| return norm_mean, norm_sd, z_score, stanine_value | |
| else: | |
| print("missing value/ wrong format") | |
| def fas_calculator(age, education, fas): | |
| if age <= 60 and education <= 12: | |
| norm_mean = 42.7 | |
| norm_sd = 13.7 | |
| z_score, stanine_value = z_score_calculator(fas, norm_mean, norm_sd) | |
| return norm_mean, norm_sd, z_score, stanine_value | |
| elif age <= 60 and education > 12: | |
| norm_mean = 46.7 | |
| norm_sd = 13.7 | |
| z_score, stanine_value = z_score_calculator(fas, norm_mean, norm_sd) | |
| return norm_mean, norm_sd, z_score, stanine_value | |
| elif age > 60 and education <= 12: | |
| norm_mean = 46.9 | |
| norm_sd = 10.4 | |
| z_score, stanine_value = z_score_calculator(fas, norm_mean, norm_sd) | |
| return norm_mean, norm_sd, z_score, stanine_value | |
| elif age > 60 and education > 12: | |
| norm_mean = 51.6 | |
| norm_sd = 12.6 | |
| z_score, stanine_value = z_score_calculator(fas, norm_mean, norm_sd) | |
| return norm_mean, norm_sd, z_score, stanine_value | |
| else: | |
| print("missing value/ wrong format") | |
| def generate_graph(test_dict): | |
| # Create a plot | |
| fig, ax = plt.subplots() | |
| # Adjust the margins to fix the labels being cut off | |
| fig.subplots_adjust(left=0.25) | |
| # Set axis labels and title | |
| ax.set_xlabel('Stanine values') | |
| ax.set_ylabel('Test') | |
| # Set the x-axis to display the stanine values | |
| ax.set_xticks([1, 2, 3, 4, 5, 6, 7, 8, 9]) | |
| ax.set_xticklabels(['1', '2', '3', '4', '5', '6', '7', '8', '9']) | |
| # Set the y-axis to display the tests | |
| ax.set_yticks([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]) | |
| # Set the test labels to the keys in test_dict (in reverse order) | |
| ax.set_yticklabels(reversed(list(test_dict.keys()))) | |
| # Set the range of the x-axis | |
| ax.set_xlim([0, 10]) | |
| i = 1 | |
| for test in reversed(list(test_dict.keys())): | |
| #print("the test is", test) | |
| # check if values are not empty | |
| ax.scatter(test_dict[test][4], i, s=50, color='black', label=test) | |
| i = i + 1 | |
| # Save the graph as a png file | |
| fig.savefig('test_profile.png') | |
| return 'test_profile.png' | |
| def create_pdf(test_dict, logo_path, plot_path): | |
| pdf = FPDF() | |
| pdf.add_page() | |
| pdf.set_xy(0, 0) | |
| pdf.set_font("Arial", size=12) | |
| # Add logos | |
| x_positions = [25, 85, 145] | |
| for i, logo_path in enumerate(logo_paths): | |
| pdf.image(logo_path, x=x_positions[i], y=8, w=40) | |
| pdf.set_xy(10, 50) | |
| # Add title and center it | |
| title = "Patient Summary" | |
| pdf.set_font("Times", style="B", size=12) | |
| title_width = pdf.get_string_width(title) + 6 | |
| pdf.cell((210 - title_width) / 2) | |
| pdf.cell(title_width, 10, title, 0, 1, "C") | |
| # Add z-score and center it | |
| pdf.set_font("Times", size=12) | |
| tests_per_line = 1 | |
| tests_count = len(test_dict) | |
| line_count = tests_count // tests_per_line + (1 if tests_count % tests_per_line > 0 else 0) | |
| test_index = 0 | |
| left_margin = 15 | |
| col_width = (210 - 2 * left_margin) / tests_per_line | |
| for line in range(line_count): | |
| pdf.set_x(left_margin) | |
| for test in list(test_dict.keys())[test_index:test_index + tests_per_line]: | |
| # Set the font to bold for the test value | |
| pdf.set_font("Arial", style="B", size=8) | |
| test_text = "{}: ".format(test) | |
| test_width = pdf.get_string_width(test_text) | |
| pdf.cell(test_width, 6, test_text, 0, 0, "C") # Changed the line height to 6 | |
| # Set the font to normal for the rest of the text | |
| pdf.set_font("Arial", size=8) | |
| z_score_text = "{:.2f} (Mean: {:.2f}, Std: {:.2f})".format( | |
| test_dict[test][3], test_dict[test][1], test_dict[test][2] | |
| ) | |
| z_score_width = pdf.get_string_width(z_score_text) + 2 # Reduced the additional width to 2 | |
| pdf.cell((210 / tests_per_line - test_width - z_score_width) / 2) | |
| pdf.cell(z_score_width, 6, z_score_text, 0, 0, "C") # Changed the line height to 6 | |
| test_index += 1 | |
| pdf.ln(12) # Reduced the line spacing to 12 | |
| # Add logo | |
| pdf.add_page() | |
| pdf.image(plot_path, x=10, y=20, w=200) | |
| # pdf.set_xy(10, 40) | |
| # Add tool description and center it | |
| pdf.set_xy(10, 200) | |
| pdf.set_font("Arial", size=10) | |
| description = "This PDF report was generated using the Patient Summary App." | |
| pdf.multi_cell(0, 10, description, 0, "C") | |
| # Add explanatory text about the collaboration between KI and KTH | |
| pdf.set_xy(10, 220) | |
| pdf.set_font("Arial", size=8) | |
| collaboration_text = ( | |
| "Den här PDF:en är en del av ett samarbetsprojekt mellan Karolinska Institutet (KI) och " | |
| "Kungliga Tekniska Högskolan (KTH) med målsättningen att använda artificiell intelligens (AI) och " | |
| "teknik för att minska administration i sjukhusarbete. Projektet fokuserar på att utveckla och " | |
| "implementera AI-baserade lösningar för att förbättra arbetsflöden, öka effektiviteten och " | |
| "minska den administrativa bördan för sjukvårdspersonal. För frågor om formuläret kontakta Fredrik Sand fredrik.sand-aronsson@regionstockholm.se, för frågor om teknik kontakta Birger Moëll bmoell@kth.se." | |
| ) | |
| line_width = 190 | |
| line_height = pdf.font_size_pt * 0.6 | |
| lines = collaboration_text.split(' ') | |
| current_line = '' | |
| for word in lines: | |
| if pdf.get_string_width(current_line + word) < line_width: | |
| current_line += word + ' ' | |
| else: | |
| pdf.cell(line_width, line_height, current_line, 0, 1) | |
| current_line = word + ' ' | |
| pdf.cell(line_width, line_height, current_line, 0, 1) | |
| return pdf | |
| def pdf_to_base64(pdf): | |
| with open(pdf, "rb") as file: | |
| return base64.b64encode(file.read()).decode('utf-8') | |
| # Title and description | |
| st.title("Language profile") | |
| st.write("Enter your test score, to calculate scores and create a PDF with the results.") | |
| # Input fields | |
| #test_score = st.number_input("Test Score", min_value=0, value=0, step=1) | |
| age = st.number_input("Age", min_value=0, value=18, step=1) | |
| education_level = st.number_input("Education Level in years", min_value=0, value=18, step=1) | |
| isw = st.number_input("ISW", min_value=0.0, value=0.0, step=0.01) | |
| bnt = st.number_input("BNT", min_value=0, value=0, step=1) | |
| fas = st.number_input("FAS", min_value=0, value=0, step=1) | |
| animal = st.number_input("Animal", min_value=0, value=0, step=1) | |
| verb = st.number_input("Verb", min_value=0, value=0, step=1) | |
| repetition = st.number_input("Repetition", min_value=0, value=0, step=1) | |
| logicogrammatic = st.number_input("Logicogrammatic", min_value=0, value=0, step=1) | |
| inference = st.number_input("Inference", min_value=0, value=0, step=1) | |
| reading_speed = st.number_input("Reading Speed", min_value=0, value=0, step=1) | |
| decoding_words = st.number_input("Decoding Words", min_value=0.0, value=0.0, step=0.01) | |
| decoding_non_words = st.number_input("Decoding Non-Words", min_value=0.0, value=0.0, step=0.01) | |
| months_backward = st.number_input("Months Backward", min_value=0.0, value=0.0, step=0.01) | |
| pataka = st.number_input("Pataka", min_value=0.0, value=0.0, step=0.01) | |
| # add all the tests | |
| # Calculate mean and standard deviation based on age and education level | |
| # For simplicity, we will use made-up values for mean and std_dev | |
| mean = np.random.randint(50, 100) | |
| std_dev = np.random.randint(10, 30) | |
| # Calculate z-score and display result | |
| if st.button("Calculate Z-Score"): | |
| profile = test_profile(age, education_level, isw, bnt, fas) | |
| # calculate the isw iq score | |
| isw_mean, isw_std, isw_iq, isw_stanine = isw_calculator(age, education_level, isw) | |
| # for each value in the profile, calculate the z-score | |
| bnt_mean, bnt_std, z_bnt, stanine_bnt = bnt_calculator(age, education_level, bnt) | |
| fas_mean, fas_std, z_fas, stanine_fas = fas_calculator(age, education_level, fas) | |
| animal_mean, animal_std, animal_z, animal_stanine = test_calculator(age, education_level, animal, "animal") | |
| verb_mean, verb_std, verb_z, verb_stanine = test_calculator(age, education_level, verb, "verb") | |
| repetition_mean, repetition_std, repetition_z, repetition_stanine = test_calculator(age, education_level, repetition, "repetition") | |
| months_backward_mean, months_backward_std, months_backward_z, months_backward_stanine = test_calculator(age, education_level, months_backward, "months_backward", invert=True) | |
| # months_backward_z = months_backward_z * -1 | |
| # print("the months backw z is: ", months_backward_z) | |
| logicogrammatic_mean, logicogrammatic_std, logicogrammatic_z, logicogrammatic_stanine = test_calculator(age, education_level, logicogrammatic, "logicogrammatic") | |
| inference_mean, inference_std, inference_z, inference_stanine = test_calculator(age, education_level, inference, "inference") | |
| reading_speed_mean, reading_speed_std, reading_speed_z, reading_speed_stanine = test_calculator(age, education_level, reading_speed, "reading_speed") | |
| decoding_words_mean, decoding_words_std, decoding_words_z, decoding_words_stanine = test_calculator(age, education_level, decoding_words, "decoding_words") | |
| decoding_non_words_mean, decoding_non_words_std, decoding_non_words_z, decoding_non_words_stanine = test_calculator(age, education_level, decoding_non_words, "decoding_non_words") | |
| pataka_mean, pataka_std, pataka_z, pataka_stanine = test_calculator(age, education_level, pataka, "pataka") | |
| ## add all the tests with their values to an array | |
| ## CREATA A DICTORINARY WITH ALL THE TESTS AND THEIR Z-SCORES AND STANINE VALUES | |
| test_dict = { | |
| "bnt": [bnt, bnt_mean, bnt_std, z_bnt, stanine_bnt], | |
| "fas": [fas, fas_mean, fas_std, z_fas, stanine_fas], | |
| "isw": [isw, isw_mean, isw_std, isw_iq, isw_stanine], | |
| "animal": [animal, animal_mean, animal_std, animal_z, animal_stanine], | |
| "verb": [verb, verb_mean, verb_std, verb_z, verb_stanine], | |
| "repetition": [repetition, repetition_mean, repetition_std, repetition_z, repetition_stanine], | |
| "months_backward": [months_backward, months_backward_mean, months_backward_std, months_backward_z, months_backward_stanine], | |
| "logicogrammatic": [logicogrammatic, logicogrammatic_mean, logicogrammatic_std, logicogrammatic_z, logicogrammatic_stanine], | |
| "inference": [inference, inference_mean, inference_std, inference_z, inference_stanine], | |
| "reading_speed": [reading_speed, reading_speed_mean, reading_speed_std, reading_speed_z, reading_speed_stanine], | |
| "decoding_words": [decoding_words, decoding_words_mean, decoding_words_std, decoding_words_z, decoding_words_stanine], | |
| "decoding_non_words": [decoding_non_words, decoding_non_words_mean, decoding_non_words_std, decoding_non_words_z, decoding_non_words_stanine], | |
| "pataka": [pataka, pataka_mean, pataka_std, pataka_z, pataka_stanine] | |
| } | |
| # z_values = [z_bnt, z_fas, animal_z, verb_z, repetition_z, months_backward_z, logicogrammatic_z, inference_z, reading_speed_z, decoding_words_z, decoding_non_words_z, pataka_z] | |
| # ## add all the stanines to a list | |
| # stanine_values = [stanine_bnt, stanine_fas, animal_stanine, verb_stanine, repetition_stanine, months_backward_stanine, logicogrammatic_stanine, inference_stanine, reading_speed_stanine, decoding_words_stanine, decoding_non_words_stanine, pataka_stanine] | |
| # loop over and write out all the z values | |
| # loop over all the values in test dict and print out the z-score, mean and std_dev and stanine | |
| for key, value in test_dict.items(): | |
| st.write(f"Your {key} z-score is: {value[3]:.2f}") | |
| st.write(f"Mean: {value[1]}, Standard Deviation: {value[2]}") | |
| st.write(f"Stanine: {value[4]}") | |
| # Create PDF | |
| logo_paths = ["logo.jpg", "logo2.jpg", "logo3.jpg"] | |
| # create the plot from the dataframe | |
| # check if education level is more than 12 years, if more than 12, set value to one, otherwise zero | |
| plot_path = generate_graph(test_dict) | |
| # create an image from the plot and add to streamlit display | |
| image = Image.open(plot_path) | |
| st.image(image, caption='Stanine plot', use_column_width=True) | |
| pdf_filename = "z_score_report.pdf" | |
| pdf = create_pdf(test_dict, logo_paths, plot_path) | |
| pdf.output(name=pdf_filename) | |
| # Download PDF | |
| with open(pdf_filename, "rb") as file: | |
| base64_pdf = base64.b64encode(file.read()).decode('utf-8') | |
| pdf_display = f'<a href="data:application/octet-stream;base64,{base64_pdf}" download="{pdf_filename}">Download PDF</a>' | |
| st.markdown(pdf_display, unsafe_allow_html=True) | |
| # Remove PDF file after download | |
| if os.path.exists(pdf_filename): | |
| os.remove(pdf_filename) |