Create app.py

app.py

@@ -0,0 +1,555 @@
+import json
+import os
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict
+from PIL import Image
+
+import numpy as np
+import pandas as pd
+import streamlit as st
+from fsspec.implementations.local import LocalFileSystem
+from huggingface_hub import HfFileSystem
+
+import streamlit.components.v1 as components
+
+@dataclass
+class Field:
+    type: str
+    title: str
+    name: str = None
+    mandatory: bool = True
+    # if value of field is in the list of those values, makes following siblings mandatory
+    following_mandatory_values: list = False
+    skip_mandatory: bool = False
+    help: Optional[str] = None
+    children: Optional[List['Field']] = None
+    other_params: Optional[Dict[str, object]] = field(default_factory=lambda: {})
+
+# Function to get user ID from URL
+def get_param_from_url(param):
+    user_id = st.query_params.get(param, "")
+    return user_id
+
+########################################################################################
+# CHANGE THE FOLLOWING VARIABLES ACCORDING TO YOUR NEEDS
+
+# 'local' or 'hf'. hf is for Hugging Face file system but has limits on the number of access per hour
+filesystem = 'hf'
+# path to repo or local file system TODO rename
+input_repo_path = 'datasets/emvecchi/therapy_annotation'
+output_repo_path = 'datasets/emvecchi/therapy_annotation/pilot'
+
+
+to_annotate_file_name = 'to_annotate.csv'  # CSV file to annotate
+COLS_TO_SAVE = ['dialogue_id','dialogue_name','generatedPatient']
+
+agreement_labels = ['strongly disagree', 'disagree', 'neither agree no disagree', 'agree', 'strongly agree']
+quality_labels = ['very poor', 'poor', 'acceptable', 'good', 'very good']
+priority_labels = ['not a priority', 'low priority', 'neutral', 'moderate priority', 'high priority']
+yes_no_labels = ['no','yes']
+yes_no_other_labels = ['no','yes','other']
+default_labels = agreement_labels
+
+function_choices = ['Broadening Discussion', 
+                    'Improving Comment Quality', 
+                    'Content Correction', 
+                    'Keeping Discussion on Topic', 
+                    'Organizing Discussion', 
+                    'Policing', 
+                    'Resolving Site Use Issues', 
+                    'Social Functions', 
+                    'None',
+                    'Other']
+          
+default_choices = function_choices
+
+guidelines_text = 'Please read <a href="https://tinyurl.com/tjy8swn2">the guidelines</a>'
+study_code = os.environ.get("STUDY_CODE")
+failed_sanity_check_code = os.environ.get("FAILED_CODE")
+redirect_url = f'https://app.prolific.com/submissions/complete?cfc={study_code}'
+failed_redirect_url = f'https://app.prolific.com/submissions/complete?cfc={failed_sanity_check_code}'
+
+annotation_guidelines_fields: List[Field] = [
+    Field(name="annotation_guidelines", type="radio", title="Did you read the guidelines?", mandatory=True,
+          other_params={'labels': ['Yes, in detail, and I understand the study',
+                                   'Yes, in detail, but still confused',
+                                   'Yes, I skimmed it',
+                                   'I will read it later',
+                                   'No, not interested in reading them',
+                                   'I can not open the link',
+                                   ],
+                        'accepted_values': [0]}),
+]
+
+intro_fields: List[Field] = [
+    Field(type="container", title="**Participant Profession**", children=[
+        Field(name="intro_profession", type="radio", title="**What is your (most recent) job or profession?**", 
+             other_params={'labels': ['Software Developer / Engineer',
+                                      'Data Scientist / Analyst',
+                                      'Teacher / Educator',
+                                      'Student',
+                                      'Research Scientist / Academic Researcher',
+                                      'Marketing Sector',
+                                      'Journalist / Writer',
+                                      'Financial Analyst',
+                                      'Business Manager / Consultant',
+                                      'Healthcare Professional (e.g., Nurse, Doctor)',
+                                      'Customer Service Representative',
+                                      'Graphic Designer',
+                                      'Sales Representative',
+                                      'Entrepreneur / Business Owner',
+                                      'Other'],
+                          }, mandatory=True, following_mandatory_values=['Other']),
+        Field(name="intro_profession_other", type="text", title="*If Other, please specify:*", mandatory=False),
+    ]),
+    Field(type="container", title="**Experience with Moderation**", children=[
+        Field(name="intro_mod_experience", type="y_n_radio",
+                title="**Have you ever worked as a moderator in an online community?**", mandatory=True, following_mandatory_values=[1]),
+        Field(name="intro_mod_experience_info", type="text",
+                title="*If yes, where did you moderate, and for how long?*", mandatory=False),
+        Field(name="intro_interaction_experience", type="likert_radio",
+                   title="**How would you quantify your experience with online moderation or interacting with moderators?** ", other_params={'labels': ['No Experience', 'Little', 'Average', 'Decent', 'Extensive Experience']},
+                     mandatory=True),
+        Field(name="intro_interaction_frequency", type="likert_radio",
+                   title="**How often do you encounter or engage with moderators in the online spaces you frequent?**", other_params={'labels': ['Never', 'Rarely', 'Sometimes', 'Often', 'Always']},
+                     mandatory=True),
+        Field(name="intro_mod_confidence", type="likert_radio",
+                   title="**Before starting this study, based on your background and the tutorial, how confident do you feel about your ability to take on the role of a moderator in an online discussion forum?**", other_params={'labels': ['Not Confident', 'Slightly Confident', 'Moderately Confident', 'Very Confident', 'Extremely Confident']},
+                     mandatory=True),
+        Field(name="intro_active_passive", type="y_n_radio",
+                title="**Would you describe your role in online discussions as more *active* (writing, replying to comments) or more *passive* (reading, liking)?**", mandatory=True, other_params={'labels': ['active', 'passive']}),
+    ]),
+    Field(type="container", title="**If you were a moderator...**", children=[
+        Field(name="intro_moderation_goals", type="textarea", title="**As a moderator, what would be your goals/objectives for a comment section?**"),
+        Field(name="intro_experience", type="textarea", title="**What would you feel contributes to a good experience for the users/discussion?**"),
+        Field(name="intro_valuable_comment", type="textarea", title="**What makes a comment or contribution valuable?**"),
+        Field(name="intro_bad_comment", type="textarea", title="**What makes a comment or contribution of poor quality, unconstructive or detrimental to the discussion?**"),
+        Field(name="intro_mod_ai_hum", type='textarea', title="**What do you think is the most challenging aspect of moderation that only humans can do well or better than AI?**", mandatory=True),
+    ]),
+]
+
+concluding_fields: List[Field] = [
+    Field(type="container", title="**Concluding Questions**", children=[
+        Field(name="conc_general_ease", type="likert_radio", title="**Determining when an instance would indeed benefit from moderator intervention was straightforward (easy to annotate).**"),
+        Field(name="conc_guess_mod_prediction", type="likert_radio", title="**I had a pretty clear idea of which instances were predicted to need moderation by your tool, and which weren't.**"),
+        Field(name="conc_overall_usefullness", type="likert_radio", title="**If I were a moderator, having a tool that accurately predicts and flags comments needing moderation would significantly aid in my tasks.**"),
+        Field(name="conc_decision_making", type="textaread", title="**If I were a moderator, would a tool with accurate predictions assist you in making *more informed* moderation decisions? How so?**"),
+        Field(name="conc_bottleneck", type="textarea", title="**What do you feel is the largest bottleneck (or obstacle) moderators face in online discussion moderation?**"),
+        Field(name="conc_needs", type="textarea", title="**Beyond the goals of this research and annotation task, what assistance do you feel computational tools (like AI) could provide to your task?**"),
+    ]),
+]
+
+fields: List[Field] = [
+    Field(name="patient", type="input_col", title="**Patient::**"),
+    Field(type="expander", title="**Preceeding Comment:** *(expand)*", children=[
+        Field(name="dialogue_name", type="input_col", title=""),
+    ]),
+
+    Field(type="container", title="**Session-/Patient-Specific Properties**", children=[
+        Field(name="to_moderate", type="y_n_radio",
+                   title="Explicit mention of clinical diagnosis?", mandatory=True),
+        Field(name="priority_level", type="likert_radio",
+                   title="Emotional State", other_params={'labels': priority_labels}, mandatory=True),
+    ]),
+
+    Field(type="container", title="**Rupture-Specific Properties**", children=[
+        Field(name="mod_function", type="multiselect",
+                     title="What type of rupture markers are found? *(Multiple selection possible)*", 
+                     mandatory=False, following_mandatory_values=['Other (please specify)']),
+        Field(name="mod_function_other", type="text", title="*If Other, please specify:*", mandatory=False),
+        Field(name="rupture_line", type="text", title="What lines demonstrate the rupture markers you notice?", mandatory=False),
+    ]),
+
+    Field(type="container", title="**True-To-Patient-Prompt Properties**", children=[
+        Field(name="helpful", type="y_n_radio",
+                title="Did the patient remain true to the provided patient prompt?", mandatory=True, 
+                following_mandatory_values=[1]),
+    ]),
+    
+    Field(type="container", title="**Other**", children=[
+        Field(name="other_comments", type="text", title="Please provide any additional details or information: *(optional)*", mandatory=False),
+    ]),
+]
+url_conditional_fields = [
+    Field(name="skip", type="skip_checkbox",
+          title="*I am uncomfortable annotating this text and  voluntarily skip this instance*", mandatory=False)
+]
+INPUT_FIELD_DEFAULT_VALUES = {'slider': 0,
+                              'text': '',
+                              'textarea': '',
+                              'checkbox': False,
+                              'radio': None,
+                              'select_slider': 0,
+                              'multiselect': [],
+                              'likert_radio': None,
+                              'y_n_radio': None}
+SHOW_HELP_ICON = False
+SHOW_VALIDATION_ERROR_MESSAGE = True
+
+########################################################################################
+if filesystem == 'hf':
+    HF_TOKEN = os.environ.get("HF_TOKEN_WRITE")
+    print("is none?", HF_TOKEN is None)
+    hf_fs = HfFileSystem(token=HF_TOKEN)
+else:
+    hf_fs = LocalFileSystem()
+
+def get_start_index():
+    if hf_fs.exists(output_repo_path + '/' + get_base_path()):
+        files = hf_fs.ls(output_repo_path + '/' + get_base_path())
+        return len(files) -2
+    else:
+        return -1
+
+def read_data():
+    assert st.session_state.batch, "Batch not provided"
+    with hf_fs.open(input_repo_path + '/' + to_annotate_file_name.format(batch=st.session_state.batch)) as f:
+        return pd.read_csv(f)
+
+def read_saved_data():
+    _path = get_path()
+    if hf_fs.exists(output_repo_path + '/' + _path):
+        with hf_fs.open(output_repo_path + '/' + _path) as f:
+            try:
+                return json.load(f)
+            except json.JSONDecodeError as e:
+                print(e)
+    return None
+    
+# Write a remote file
+def save_data(data):
+    if not hf_fs.exists(f"{output_repo_path}/{get_base_path()}"):
+        hf_fs.mkdir(f"{output_repo_path}/{get_base_path()}")
+    with hf_fs.open(f"{output_repo_path}/{get_path()}", "w") as f:
+        f.write(json.dumps(data))
+
+def get_base_path():
+    return f"{st.session_state.batch}/{st.session_state.user_id}"
+
+def get_path():
+    return f"{get_base_path()}/{st.session_state.current_index}.json"
+
+def display_dialogue(dialogue_path):
+    dialogue_text = load_text(dialogue_path)
+    st.markdown(
+        f"<details><summary><b>Annotation Guidelines</b></summary><div>{dialogue_text}</div></details><br>",
+    unsafe_allow_html=True)
+    
+def display_image(image_path):
+    with hf_fs.open(image_path) as f:
+        img = Image.open(f)
+        st.image(img, caption='8 most contributing properties', use_column_width=True)
+        
+#################################### Streamlit App ####################################
+
+# Function to navigate rows
+def navigate(index_change):
+    st.session_state.current_index += index_change
+    # only works consistently if done before rerun
+    js = '''
+    <script>
+        setTimeout(function() {
+            var titleElement = window.parent.document.querySelector("h1");
+            if (titleElement) {
+                titleElement.scrollIntoView({behavior: "smooth", block: "start"});
+            }
+        }, 100);
+    </script>
+    '''
+    st.components.v1.html(js, height=0)
+    # https://discuss.streamlit.io/t/click-twice-on-button-for-changing-state/45633/2
+
+    # disable text input enter to submit
+    # https://discuss.streamlit.io/t/text-input-how-to-disable-press-enter-to-apply/14457/6
+    components.html(
+        """
+        <script>
+        const inputs = window.parent.document.querySelectorAll('input');
+        inputs.forEach(input => {
+            input.addEventListener('keydown', function(event) {
+                if (event.key === 'Enter') {
+                    event.preventDefault();
+                }
+            });
+        });
+        </script>
+        """,
+        height=0
+    )
+    st.rerun()
+
+def show_field(f: Field, index: int, data_collected):
+    if f.type not in INPUT_FIELD_DEFAULT_VALUES.keys():
+        st.session_state.following_mandatory = False
+        match f.type:
+            case 'input_col':
+                value = st.session_state.data.iloc[index][f.name]
+                if value and value is not np.nan:
+                    st.write(f.title)
+                    if f.name == 'image_name':
+                        display_image(os.path.join(input_repo_path, 'images', value))
+                    elif f.name == 'dialogue_name':
+                        #display_dialogue(os.path.join(input_repo_path, 'dialogues', value))
+                        display_dialogue(os.path.join(input_repo_path, value))
+                    else:
+                        st.write(value)
+            case 'markdown':
+                st.markdown(f.title)
+            case 'expander' | 'container':
+                with (st.expander(f.title) if f.type == 'expander' else st.container(border=True)):
+                    if f.type == 'container':
+                        st.markdown(f.title)
+                    for child in f.children:
+                        show_field(child, index, data_collected)
+            case 'skip_checkbox':
+                st.checkbox(f.title, key=f.name, value=False)
+    else:
+        key = f.name + str(index)
+        st.session_state.data_inputs_keys.append(f.name)
+        value = st.session_state[key] if key in st.session_state else \
+            (data_collected[f.name] if data_collected else INPUT_FIELD_DEFAULT_VALUES[f.type])
+        if not SHOW_HELP_ICON:
+            f.title = f'**{f.title}**\n\n{f.help}' if f.help else f.title
+        
+        validation_error = False
+        
+        # form is not displayed for first time
+        if st.session_state.form_displayed == st.session_state.current_index:
+            if st.session_state.following_mandatory and f.skip_mandatory:
+                st.session_state.following_mandatory = False
+            if f.following_mandatory_values and st.session_state[key] in f.following_mandatory_values:
+                st.session_state.following_mandatory = True
+            if f.mandatory or st.session_state.following_mandatory:
+                if st.session_state[key] == INPUT_FIELD_DEFAULT_VALUES[f.type]:
+                    st.session_state.valid = False
+                    validation_error = True
+                elif f.following_mandatory_values and st.session_state[key] in f.following_mandatory_values:
+                    st.session_state.following_mandatory = True
+        
+            # check for any unaccepted values
+            if (
+                    (f.other_params.get('accepted_values') and
+                     value not in f.other_params.get('accepted_values')) or
+                    (f.other_params.get('accepted_values_per_sample') and
+                     index in f.other_params.get('accepted_values_per_sample') and
+                     value not in f.other_params.get('accepted_values_per_sample').get(index))
+            ):
+                st.session_state.unacceptable_response = True
+
+        if f.mandatory or st.session_state.following_mandatory:
+            f.title += " :red[* required!]" if (validation_error and not SHOW_VALIDATION_ERROR_MESSAGE) else' :red[*]'
+        f.help = None
+
+        match f.type:
+            case 'checkbox':
+                st.checkbox(f.title,
+                            key=key,
+                            value=value, help=f.help)
+            case 'radio':
+                labels = default_labels if not f.other_params.get('labels') else f.other_params.get('labels')
+                st.radio(f.title,
+                         options=range(len(labels)),
+                         format_func=lambda x: labels[x],
+                         key=key,
+                         index=value, help=f.help, horizontal=False)
+            case 'slider':
+                st.slider(f.title,
+                          min_value=0, max_value=6, step=1,
+                          key=key,
+                          value=value, help=f.help)
+            case 'select_slider':
+                labels = default_labels if not f.other_params.get('labels') else f.other_params.get('labels')
+                st.select_slider(f.title,
+                                 options=[0, 20, 40, 60, 80, 100],
+                                 format_func=lambda x: labels[x // 20],
+                                 key=key,
+                                 value=value, help=f.help)
+            case 'multiselect':
+                choices = default_choices if not f.other_params.get('choices') else f.other_params.get('choices')
+                st.multiselect(f.title,
+                                options = choices,
+                                format_func=lambda x: x,
+                                key=key, max_selections=3,
+                                default=value, help=f.help)
+            case 'likert_radio':
+                labels = default_labels if not f.other_params.get('labels') else f.other_params.get('labels')
+                st.radio(f.title,
+                         options=[0, 1, 2, 3, 4],
+                         format_func=lambda x: labels[x],
+                         key=key,
+                         index=value, help=f.help, horizontal=True)
+            case 'y_n_radio':
+                labels = yes_no_labels if not f.other_params.get('labels') else f.other_params.get('labels')
+                st.radio(f.title,
+                         options=[0, 1],
+                         format_func=lambda x: labels[x],
+                         key=key,
+                         index=value, help=f.help, horizontal=True)
+            case 'text':
+                st.text_input(f.title, key=key, value=value, max_chars=None)
+            case 'textarea':
+                st.text_area(f.title, key=key, value=value, max_chars=None)
+
+        if validation_error:
+            st.session_state.unacceptable_response = False
+            st.error(f"Mandatory field")
+
+def show_fields(fields: List[Field]):
+    st.session_state.valid = True
+    index = st.session_state.current_index
+    data_collected = read_saved_data()
+    st.session_state.data_inputs_keys = []
+    st.session_state.following_mandatory = False
+
+    for field in fields:
+        show_field(field, index, data_collected)
+
+    submitted = st.form_submit_button("Submit")
+    if submitted:
+        if 'unacceptable_response' in st.session_state and st.session_state.unacceptable_response:
+            prep_and_save_data(index, ('skip' in st.session_state and st.session_state['skip']))
+            st.rerun()
+        skip_sample = ('skip' in st.session_state and st.session_state['skip'])
+        if not skip_sample and not st.session_state.valid:
+            st.error("Please fill in all mandatory fields")
+            # st.rerun() # filed-out values are not shown otherwise
+        else:
+            with st.spinner(text="saving"):
+                prep_and_save_data(index, skip_sample)
+            st.success("Feedback submitted successfully!")
+            navigate(1)
+
+    st.session_state.form_displayed = st.session_state.current_index
+
+def prep_and_save_data(index, skip_sample):
+    save_data({
+        'user_id': st.session_state.user_id,
+        'index': st.session_state.current_index,
+        'batch': st.session_state.batch,
+        **(st.session_state.data.iloc[index][COLS_TO_SAVE].to_dict() if 0 <= index < len(st.session_state.data) else {}),
+        **{k: st.session_state[k + str(index)] for k in st.session_state.data_inputs_keys},
+        'skip': skip_sample
+    })
+
+# st.set_page_config(layout='wide')
+# Title of the app
+st.title("Should We Moderate this Comment?")
+
+st.markdown(
+    """<style>
+div[data-testid="stMarkdownContainer"] > p {
+    font-size: 1rem;
+}
+    section.main > div {max-width:60rem}
+    </style>
+    """, unsafe_allow_html=True)
+
+def add_annotation_guidelines():
+    guidelines_text = load_text("texts/guidelines.md")
+    st.write(f"username is {st.session_state.user_id}")
+    st.markdown(
+        f"<details><summary><b>Annotation Guidelines</b></summary><div>{guidelines_text}</div></details><br>",
+    unsafe_allow_html=True)
+
+if 'unacceptable_response' in st.session_state and st.session_state.unacceptable_response:
+    #error_message = "You are not eligible for this study.<br><br>"
+    error_message = "<br>"
+    if st.session_state.current_index >= -5:
+        error_message += (
+            "Thank you for your time! You will receive a small compensation for your contribution up to now. <br><br>"
+            f'Please return to the study and copy/paste this code: <b>{failed_sanity_check_code}</b>, or '
+            f'<a href="https://app.prolific.com/submissions/complete?cfc={failed_sanity_check_code}">Click Here</a>'
+        )
+    # Display the error message using custom HTML
+    st.markdown(
+        f"""
+        <div style="background-color: #f8d7da; color: #721c24; padding: 10px; border-radius: 5px; border: 1px solid #f5c6cb;">
+            <h4>Error: You are not eligible for this study.</h4> {error_message}
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+    st.stop()
+
+# batch-specific data subset
+st.session_state.batch = get_param_from_url("batch")
+
+# Load the data to annotate
+if 'data' not in st.session_state:
+    st.session_state.data = read_data()
+
+# user id
+user_id_from_url = get_param_from_url("user_id")
+if user_id_from_url:
+    st.session_state.user_id = user_id_from_url
+
+# current index
+if 'current_index' not in st.session_state:
+    start_index = get_start_index()
+    if start_index < len(st.session_state.data)-1:
+        st.session_state.current_index = start_index
+    else:
+        st.session_state.current_index = start_index+1
+    st.session_state.form_displayed = -1
+
+if get_param_from_url('show_extra_fields'):
+    fields += url_conditional_fields
+else:
+    fields += url_conditional_fields
+
+def add_validated_submit(fields, message):
+    st.session_state.form_displayed = st.session_state.current_index
+    if st.form_submit_button("Submit"):
+        if all(not x for x in fields):
+            st.error(message)
+        else:
+            navigate(1)
+
+def add_checked_submit():
+    check = st.checkbox('I agree', key='consent')
+    add_validated_submit([check], "Please agree to give your consent to proceed")
+
+def load_text(file):
+    with open(file, "r") as file:
+        consent_text = file.read()
+    return consent_text
+
+if st.session_state.current_index == -6:
+    with st.form("data_form"):
+        st.markdown(load_text("texts/consent_text.md"))
+        add_checked_submit()
+
+elif st.session_state.current_index == -1:
+    if st.session_state.get('user_id'):
+        navigate(1)
+    else:
+        with st.form("data_form"):
+            st.session_state.user_id = st.text_input('User ID', value=user_id_from_url)
+            add_validated_submit([st.session_state.user_id], "Please enter a valid user ID")
+
+elif st.session_state.current_index < len(st.session_state.data):
+    add_annotation_guidelines()
+    with st.form("data_form"+str(st.session_state.current_index)):
+        show_fields(fields)
+
+elif st.session_state.current_index == len(st.session_state.data):
+    st.write(f"**Thank you for taking part in this study!** \n ")
+    if st.button("Previous"):
+        navigate(-1)
+
+# Navigation buttons
+if -4 < st.session_state.current_index < len(st.session_state.data):
+    if st.button("Previous"):
+        navigate(-1)
+
+if 0 <= st.session_state.current_index < len(st.session_state.data):
+    st.write(f"Page {st.session_state.current_index + 1} out of {len(st.session_state.data)}")
+
+st.markdown(
+    """<style>
+    div[data-testid="InputInstructions"] {
+        visibility: hidden;
+    }
+    </style>""", unsafe_allow_html=True
+)
+