updated with resuming surveys:

README.md

@@ -26,4 +26,5 @@ Check out the configuration reference at https://huggingface.co/docs/hub/spaces-
 [ ] Implement questions with proper buttons (with text)
 [ ] Back button
 [ ] Dataset linking
-[ ] prettify the context field with new lines and highlighting popularity etc. keywords in bold
+[ ] prettify the context field with new lines and highlighting popularity etc. keywords in bold
+[ ] Doing it for two models

app.py

@@ -2,83 +2,44 @@ import json
 from typing import Dict
 
 from db.schema import Feedback, Response
-from db.crud import ingest, read
+from db.crud import ingest, read, save_feedback
 import pandas as pd
 import streamlit as st
 from datetime import datetime
 import os
 from dotenv import load_dotenv
-from views.intro_screen import username_screen
-from views.questions_screen import new_questions_screen
+from views.intro_screen import welcome_screen
+from views.questions_screen import questions_screen, survey_completed
+from views.continue_survey import continue_survey_screen
 from css.layout import custom_css
 
 load_dotenv()
 VALIDATION_CODE = os.getenv("VALIDATION_CODE")
 
 
-class SurveyState:
-    """Class to handle survey state management"""
-
-    def __init__(self):
-        pass
-
-    def save_state(self, prolific_id: str, current_state: Dict) -> None:
-        """Save current state to Firebase"""
-        try:
-            # Saving to Firebase via the ingest function
-            feedback = Feedback(user_id=prolific_id, time_stamp=datetime.now().isoformat(),
-                                responses=current_state["responses"])
-            ingest(feedback)  # Ingest feedback to Firebase
-            st.success("Your progress has been saved! You can continue later.")
-        except Exception as e:
-            st.error(f"Error saving state to Firebase: {e}")
-
-    def load_state(self, prolific_id: str) -> Dict:
-        """Load state for a specific user from Firebase"""
-        try:
-            # Retrieve the state from Firebase for the given Prolific ID
-            state = self.get_state_from_firebase(prolific_id)
-            if state:
-                return state
-        except Exception as e:
-            st.error(f"Error loading state from Firebase: {e}")
-        return {}
-
-    class SurveyState:
-        """Class to handle survey state management"""
-
-        def __init__(self):
-            pass
-
-        @staticmethod
-        def save_state(self, username: str, current_state: Dict) -> None:
-            """Save current state to Firebase"""
-            try:
-                # Saving to Firebase via the ingest function
-                feedback = Feedback(user_id=username, time_stamp=datetime.now().isoformat(),
-                                    responses=current_state["responses"])
-                ingest(feedback)  # Ingest feedback to Firebase
-                st.success("Your progress has been saved! You can continue later.")
-            except Exception as e:
-                st.error(f"Error saving state to Firebase: {e}")
-
-        def load_state(self, username: str) -> Dict:
-            """Load state for a specific user from Firebase"""
-            try:
-                # Retrieve the state from Firebase for the given Prolific ID
-                state = self.get_state_from_firebase(username)
-                if state:
-                    return state
-            except Exception as e:
-                st.error(f"Error loading state from Firebase: {e}")
-            return {}
-
-        def get_state_from_firebase(self, username: str) -> Dict:
-            # Placeholder method to simulate getting state from Firebase
-            # In practice, you will query Firebase to get the current state
-            data = read(username)
-            return {}
-
+# class SurveyState:
+#     """Class to handle survey state management"""
+#
+#     def __init__(self):
+#         pass
+#
+#     def save_state(self, username: str, current_state: Dict) -> None:
+#         """Save current state to Firebase"""
+#         try:
+#             """Handles feedback submission to the database."""
+#             feedback = Feedback(
+#                 id=st.session_state.current_index + 1,
+#                 user_id=st.session_state.username,
+#                 time_stamp=datetime.now().isoformat(),
+#                 responses=st.session_state.responses,
+#             )
+#             save_feedback(feedback)
+#             st.success("Your progress has been saved! You can continue later.")
+#             st.session_state.completed = True
+#             st.rerun()
+#         except Exception as e:
+#             st.error(f"An error occurred while submitting feedback: {e}")
+#
 
 def initialization():
     """Initialize session state variables."""
@@ -90,8 +51,14 @@ def initialization():
         st.session_state.responses = []
     if "completed" not in st.session_state:
         st.session_state.completed = False
-    if "survey_state" not in st.session_state:
-        st.session_state.survey_state = SurveyState()
+    if "show_questions" not in st.session_state:
+        st.session_state.show_questions = False
+    if "survey_continued" not in st.session_state:
+        st.session_state.survey_continued = None
+    if "start_new_survey" not in st.session_state:
+        st.session_state.start_new_survey = False
+    # if "survey_state" not in st.session_state:
+    #     st.session_state.survey_state = SurveyState()
 
 
 def exit_screen():
@@ -109,45 +76,42 @@ def exit_screen():
         st.rerun()
 
 
-def submit_survey():
-    """Submit the complete survey"""
-    try:
-        feedback = Feedback(
-            id=st.session_state.current_index,
-            user_id=st.session_state.username,
-            time_stamp=datetime.now().isoformat(),
-            responses=st.session_state.responses,
-        )
-        print(feedback)
-        ingest(feedback)
-        st.session_state.completed = True
-        st.rerun()
-    except Exception as e:
-        st.error(f"An error occurred while submitting feedback: {e}")
-
-
 def reset_survey():
     """Reset the survey state to start over."""
-    st.session_state.username = None
-    st.session_state.current_index = 0
     st.session_state.responses = []
-    st.session_state.completed = False
+    st.session_state.completed = True #TODO: Change to False?
+    st.session_state.start_new_survey = True
 
 
 def ui():
     """Main function to control the survey flow."""
     custom_css()
-    data = pd.read_csv("data/gemini_results_subset.csv")[:3]
+    data = pd.read_csv("data/gemini_results_subset.csv")[:5]
     initialization()
 
-    if st.session_state.completed:
+    if st.session_state.completed and not st.session_state.start_new_survey:
         exit_screen()
         return
 
     if st.session_state.username is None:
-        username_screen()
+        welcome_screen()
     else:
-        new_questions_screen(data)
+        # Check if user progress exists in Firebase
+        saved_state = read(st.session_state.username)
+        if saved_state:
+            # If there's saved progress and the survey has not been continued, show continue screen
+            if "survey_continued" not in st.session_state or not st.session_state.survey_continued:
+                continue_survey_screen(data)
+            else:
+                if st.session_state.current_index >= len(data):
+                # If all questions have been answered, show the exit screen
+                    print("survey completed")
+                    survey_completed()
+                # Otherwise, show questions from where they left off
+                questions_screen(data)
+        else:
+            # If no saved progress (new user), start with the questions screen
+            questions_screen(data)
 
 
 if __name__ == "__main__":

db/crud.py

@@ -8,32 +8,44 @@ from db.setup import db_setup
 def ingest(data: Feedback):
     ref = db_setup()  # Ensure Firebase is initialized
     print(f"Attempting to ingest feedback data from user '{data.user_id}'...")
-    # Check if the user_id already exists in the feedback data
-    # user_id_str = str(data.user_id)
-    # existing_feedback = ref.child('feedback').order_by_child('user_id').equal_to(user_id_str).get()
-    #
-    #
-    # # TODO: This should probably change. If the same user has multiple feedbacks, we should allow it. -> change to update
-    # if existing_feedback:
-    #     print(f"Feedback from user '{data.user_id}' already exists. Ingestion aborted.")
-    # else:
-    #     # feedback_data = data.dict()  # Convert Pydantic model to a dictionary
     feedback_data = data.model_dump()
     feedback_data["time_stamp"] = feedback_data['time_stamp'].isoformat()
     ref.child('feedback').push(feedback_data)
     print(f"Feedback data from user '{data.user_id}' pushed to Firebase!")
 
 
+def save_feedback(data: Feedback):
+    ref = db_setup()  # Ensure Firebase is initialized
+    print(f"Processing feedback for user '{data.user_id}'...")
+
+    # Convert Pydantic model to dictionary
+    feedback_data = data.model_dump()
+    feedback_data["time_stamp"] = feedback_data["time_stamp"].isoformat()
+
+    # Check if the user already has feedback
+    existing_feedback = ref.child("feedback").order_by_child("user_id").equal_to(data.user_id).get()
+
+    if existing_feedback:
+        # Update existing feedback
+        for key in existing_feedback:
+            ref.child("feedback").child(key).update(feedback_data)
+        print(f"Feedback updated for user '{data.user_id}'!")
+    else:
+        # Insert new feedback
+        ref.child("feedback").push(feedback_data)
+        print(f"(Ingestion) New feedback added for user '{data.user_id}'!")
+
+
 # Read operation (Fetch feedback data from Firebase)
 def read(user_id: str):
+    """Fetch feedback data for a specific user from Firebase."""
     ref = db_setup()
     feedback_ref = ref.child('feedback').order_by_child('user_id').equal_to(user_id).get()
 
     if feedback_ref:
-        return feedback_ref
-    else:
-        print("Feedback not found!")
-        return None
+        for key, value in feedback_ref.items():
+            return value  # Return the first found entry
+    return None  # No progress found
 
 
 # Update operation (Update feedback data in Firebase)
@@ -64,6 +76,17 @@ def delete(feedback_id: int):
         print("Feedback not found to delete!")
 
 
+def reset_feedback_in_db(user_id: str):
+    """Deletes previous feedback for a user, resetting progress in Firebase."""
+    ref = db_setup()
+    feedback_ref = ref.child('feedback').order_by_child('user_id').equal_to(user_id).get()
+
+    if feedback_ref:
+        for key in feedback_ref:
+            ref.child('feedback').child(key).delete()
+        print(f"Feedback data for user '{user_id}' reset in Firebase.")
+
+
 def test():
     # Create a feedback object
     # feedback = Feedback(
@@ -101,4 +124,3 @@ def test():
     #
     # # Delete (Remove)
     # delete(1)
-

db/setup.py

@@ -34,6 +34,10 @@ def initialize_firebase():
 
 
 def db_setup():
-    initialize_firebase()
+    try:
+        initialize_firebase()
+    except Exception as e:
+        print(f"Error initializing Firebase: {e}")
+    firebase_admin.get_app()
     ref = db.reference('/')
     return ref

views/continue_survey.py

@@ -0,0 +1,57 @@
+import streamlit as st
+from db.crud import read, reset_feedback_in_db
+from views.questions_screen import questions_screen
+
+
+def continue_survey_screen(data):
+    """Screen for existing users to continue or restart their survey."""
+    st.title("Resume Your Survey")
+
+    st.write("Welcome back! Would you like to continue from where you left off or restart the survey?")
+
+    # Fetch user progress from Firebase
+    saved_state = read(st.session_state.username)
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        if st.button("Continue"):
+            if saved_state:
+                # Set session state values based on saved progress
+                st.session_state.current_index = saved_state.get("current_index", 0)
+                st.session_state.responses = saved_state.get("responses", [])
+
+                # Find the last answered config_id in responses
+                last_config_id = None
+                if st.session_state.responses:
+                    last_config_id = st.session_state.responses[-1].get("config_id")
+
+                # Set the index to the matching config_id
+                if last_config_id is not None:
+                    matching_index = data[data["config_id"] == last_config_id].index
+                    if not matching_index.empty:
+                        st.session_state.current_index = matching_index[0]+1
+
+                st.success("Resuming your survey!")
+                # Set survey_continued flag to True only when there's saved progress
+                st.session_state.survey_continued = True
+                print(st.session_state.current_index)
+                st.rerun()
+                # questions_screen(data)
+
+            else:
+                st.warning("No previous progress found. Starting a new survey.")
+                st.session_state.current_index = 0
+                st.session_state.responses = []
+
+        with col2:
+            if st.button("Restart"):
+                st.session_state.current_index = 0
+                st.session_state.responses = []
+                st.success("Survey restarted!")
+
+                # Reset Firebase data for the user
+                reset_feedback_in_db(st.session_state.username)
+
+                st.rerun()
+

views/intro_screen.py

@@ -1,6 +1,8 @@
 import streamlit as st
 import os
 from dotenv import load_dotenv
+from views.continue_survey import continue_survey_screen
+from db.crud import read
 
 load_dotenv()
 VALIDATION_CODE = os.getenv("VALIDATION_CODE")
@@ -15,28 +17,32 @@ def validate_code(input_code: str) -> bool:
     return input_code.strip() == VALIDATION_CODE
 
 
-def username_screen():
-    """Display the Prolific ID entry screen."""
+def welcome_screen():
+    """Display the welcome screen and direct users accordingly."""
     st.title("Welcome to the Feedback Survey")
 
     username_input = st.text_input("Enter your First name and press TAB:")
     validation_code_input = st.text_input("Enter the validation code to proceed and press ENTER:")
 
     next_button = st.button("Next")
+
     if (username_input and validation_code_input) or next_button:
-        # Validate Prolific ID and code
         if validate_username(username_input) and validate_code(validation_code_input):
             st.session_state.username = username_input
 
-            # Load previous state if exists
-            saved_state = st.session_state.survey_state.load_state(username_input)
-            if saved_state:
-                st.session_state.current_index = saved_state.get('current_index', 0)
-                st.session_state.responses = saved_state.get('responses', [])
-                st.success("Previous progress loaded! Continuing from where you left off.")
-            else:
-                st.success("Prolific ID and code validated! Starting new survey.")
-            st.rerun()
+            # # Check if user progress exists in Firebase
+            # saved_state = read(username_input)
+            #
+            # if saved_state:
+            #     # Show continue survey screen for returning users
+            #     st.success("Previous progress found.")
+            #     continue_survey_screen()
+            # else:
+            #     # Start fresh for new users
+            #     st.success("Starting a new survey.")
+            #     st.session_state.current_index = 0
+            #     st.session_state.responses = []
+            #     st.rerun()
         else:
             if not validate_username(username_input):
                 st.warning("Invalid Prolific ID. Please check and try again.")

views/nav_buttons.py

@@ -1,9 +1,5 @@
-import json
-from typing import Dict
-
-from db.schema import Feedback, Response
-from db.crud import ingest, read
-import pandas as pd
+from db.schema import Feedback
+from db.crud import save_feedback, read
 import streamlit as st
 from datetime import datetime
 import os
@@ -12,7 +8,23 @@ load_dotenv()
 VALIDATION_CODE = os.getenv("VALIDATION_CODE")
 
 
-def navigation_buttons(data, rating_v, rating_p0, rating_p1):
+def submit_feedback(current_index):
+    """Handles feedback submission to the database."""
+    feedback = Feedback(
+        id=current_index + 1,
+        user_id=st.session_state.username,
+        time_stamp=datetime.now().isoformat(),
+        responses=st.session_state.responses,
+    )
+    try:
+        save_feedback(feedback)
+        st.session_state.completed = True
+        st.rerun()
+    except Exception as e:
+        st.error(f"An error occurred while submitting feedback: {e}")
+
+
+def navigation_buttons(data, ratings_v, ratings_p0, ratings_p1):
     """Display navigation buttons."""
     current_index = st.session_state.current_index
 
@@ -25,22 +37,15 @@ def navigation_buttons(data, rating_v, rating_p0, rating_p1):
 
     with col2:  # Next button
         if st.button("Next"):
-            if rating_v == 0 or rating_p0 == 0 or rating_p1 == 0:
+            if any(rating == 0 for rating in [ratings_v, ratings_p0, ratings_p1]):
                 st.warning("Please provide a rating before proceeding.")
             else:
                 if current_index < len(data) - 1:
                     st.session_state.current_index += 1
                     st.rerun()
                 else:
-                    feedback = Feedback(
-                        id=current_index + 1,
-                        user_id=st.session_state.username,
-                        time_stamp=datetime.now().isoformat(),
-                        responses=st.session_state.responses,
-                    )
-                    try:
-                        ingest(feedback)
-                        st.session_state.completed = True
-                        st.rerun()
-                    except Exception as e:
-                        st.error(f"An error occurred while submitting feedback: {e}")
+                    submit_feedback(current_index)
+
+    with col3:  # Save & Resume Later button
+        if st.button("Exit & Resume Later"):
+            submit_feedback(current_index)

views/questions_screen.py

@@ -12,131 +12,148 @@ load_dotenv()
 VALIDATION_CODE = os.getenv("VALIDATION_CODE")
 
 
-def new_questions_screen(data):
+def survey_completed():
+    """Display the survey completion message."""
+    st.markdown("""
+            <div class='exit-container'>
+                <h1>You have already completed the survey! Thank you for participating!</h1>
+                <p>Your responses have been saved successfully.</p>
+                <p>You can safely close this window or start a new survey.</p>
+            </div>
+        """, unsafe_allow_html=True)
+    st.session_state.show_questions = False
+    st.session_state.completed = True
+    st.session_state.start_new_survey = True
+    # st.rerun()
+
+
+def questions_screen(data):
+    # TODO: refactor to avoid code duplication
     """Display the questions screen with split layout"""
     current_index = st.session_state.current_index
-    config = data.iloc[current_index]
-
-    # Progress bar
-    progress = (current_index + 1) / len(data)
-    st.progress(progress)
-    st.write(f"Question {current_index + 1} of {len(data)}")
-    st.subheader(f"Config ID: {config['config_id']}")
-
-    # Context information
-    st.markdown("### Context Information")
-
-    with st.expander("Persona", expanded=True):
-        st.write(config['persona'])
-
-    with st.expander("Filters & Cities", expanded=True):
-        st.write("**Filters:**", config['filters'])
-        st.write("**Cities:**", config['city'])
-
-    with st.expander("Full Context", expanded=False):
-        st.write(config['context'])
-
-    # Split layout for questions and ratings
-    col11, col12, col13, col14 = st.columns([1, 1, 1, 1])  # Sub-columns for query ratings
-    options = [0, 1, 2, 3, 4, 5]
-
-    # Query_v and its ratings
-    st.markdown("### Query_v")
-    st.write(config['query_v'])
-    col_v_1, col_v_2, col_v_3 = st.columns(3)
-    with col_v_1:
-        clarity_rating = st.radio("Clarity:", options, key=f"rating_v_clarity_{current_index}")
-
-    with col_v_2:
-        relevance_rating = st.radio("Relevance:", options, key=f"rating_v_relevance_{current_index}")
-
-    with col_v_3:
-        coverage_rating = st.radio("Coverage:", options, key=f"rating_v_coverage_{current_index}")
-
-    query_v_ratings = {
-        "clarity": clarity_rating,
-        "relevance": relevance_rating,
-        "coverage": coverage_rating,
-    }
-
-    # Query_p0 and its ratings
-    st.markdown("### Query_p0")
-    st.write(config['query_p0'])
-    col_p0_1, col_p0_2, col_p0_3, col_p0_4 = st.columns(4)
-
-    with col_p0_1:
-        clarity_rating = st.radio("Clarity:", options, key=f"rating_p0_clarity_{current_index}")
-
-    with col_p0_2:
-        relevance_rating = st.radio("Relevance:", options, key=f"rating_p0_relevance_{current_index}")
-
-    with col_p0_3:
-        coverage_rating = st.radio("Coverage:", options, key=f"rating_p0_coverage_{current_index}")
-
-    with col_p0_4:
-        persona_alignment_rating = st.radio(
-            "Persona Alignment:", options=[0, 1, 2, 3, 4],  # These are the values
-            format_func=lambda x: ["N/A", "Not Aligned", "Partially Aligned", "Aligned", "Unclear"][x],
-            key=f"rating_p0_persona_alignment_{current_index}"
-        )
-
-    # Collecting the ratings for query_p0
-    query_p0_ratings = {
-        "clarity": clarity_rating,
-        "relevance": relevance_rating,
-        "coverage": coverage_rating,
-        "persona_alignment": persona_alignment_rating
-    }
-
-    # Query_p1 and its ratings
-    st.markdown("### Query_p1")
-    st.write(config['query_p1'])
-    # Split the layout into 4 columns for query_p1 ratings
-    col_p1_1, col_p1_2, col_p1_3, col_p1_4 = st.columns(4)
-
-    with col_p1_1:
-        clarity_rating_p1 = st.radio("Clarity:", options, key=f"rating_p1_clarity_{current_index}")
-
-    with col_p1_2:
-        relevance_rating_p1 = st.radio("Relevance:", options, key=f"rating_p1_relevance_{current_index}")
-
-    with col_p1_3:
-        coverage_rating_p1 = st.radio("Coverage:", options, key=f"rating_p1_coverage_{current_index}")
-
-    with col_p1_4:
-        persona_alignment_rating_p1 = st.radio(
-            "Persona Alignment:", options=[0, 1, 2, 3, 4],  # These are the values
-            format_func=lambda x: ["N/A", "Not Aligned", "Partially Aligned", "Aligned", "Unclear"][x],
-            key=f"rating_p1_persona_alignment_{current_index}"
+    try:
+        config = data.iloc[current_index]
+
+        # Progress bar
+        progress = (current_index + 1) / len(data)
+        st.progress(progress)
+        st.write(f"Question {current_index + 1} of {len(data)}")
+        st.subheader(f"Config ID: {config['config_id']}")
+
+        # Context information
+        st.markdown("### Context Information")
+
+        with st.expander("Persona", expanded=True):
+            st.write(config['persona'])
+
+        with st.expander("Filters & Cities", expanded=True):
+            st.write("**Filters:**", config['filters'])
+            st.write("**Cities:**", config['city'])
+
+        with st.expander("Full Context", expanded=False):
+            st.write(config['context'])
+
+        # Split layout for questions and ratings
+        col11, col12, col13, col14 = st.columns([1, 1, 1, 1])  # Sub-columns for query ratings
+        options = [0, 1, 2, 3, 4, 5]
+
+        # Query_v and its ratings
+        st.markdown("### Query_v")
+        st.write(config['query_v'])
+        col_v_1, col_v_2, col_v_3 = st.columns(3)
+        with col_v_1:
+            clarity_rating = st.radio("Clarity:", options, key=f"rating_v_clarity_{current_index}")
+
+        with col_v_2:
+            relevance_rating = st.radio("Relevance:", options, key=f"rating_v_relevance_{current_index}")
+
+        with col_v_3:
+            coverage_rating = st.radio("Coverage:", options, key=f"rating_v_coverage_{current_index}")
+
+        query_v_ratings = {
+            "clarity": clarity_rating,
+            "relevance": relevance_rating,
+            "coverage": coverage_rating,
+        }
+
+        # Query_p0 and its ratings
+        st.markdown("### Query_p0")
+        st.write(config['query_p0'])
+        col_p0_1, col_p0_2, col_p0_3, col_p0_4 = st.columns(4)
+
+        with col_p0_1:
+            clarity_rating = st.radio("Clarity:", options, key=f"rating_p0_clarity_{current_index}")
+
+        with col_p0_2:
+            relevance_rating = st.radio("Relevance:", options, key=f"rating_p0_relevance_{current_index}")
+
+        with col_p0_3:
+            coverage_rating = st.radio("Coverage:", options, key=f"rating_p0_coverage_{current_index}")
+
+        with col_p0_4:
+            persona_alignment_rating = st.radio(
+                "Persona Alignment:", options=[0, 1, 2, 3, 4],  # These are the values
+                format_func=lambda x: ["N/A", "Not Aligned", "Partially Aligned", "Aligned", "Unclear"][x],
+                key=f"rating_p0_persona_alignment_{current_index}"
+            )
+
+        # Collecting the ratings for query_p0
+        query_p0_ratings = {
+            "clarity": clarity_rating,
+            "relevance": relevance_rating,
+            "coverage": coverage_rating,
+            "persona_alignment": persona_alignment_rating
+        }
+
+        # Query_p1 and its ratings
+        st.markdown("### Query_p1")
+        st.write(config['query_p1'])
+        # Split the layout into 4 columns for query_p1 ratings
+        col_p1_1, col_p1_2, col_p1_3, col_p1_4 = st.columns(4)
+
+        with col_p1_1:
+            clarity_rating_p1 = st.radio("Clarity:", options, key=f"rating_p1_clarity_{current_index}")
+
+        with col_p1_2:
+            relevance_rating_p1 = st.radio("Relevance:", options, key=f"rating_p1_relevance_{current_index}")
+
+        with col_p1_3:
+            coverage_rating_p1 = st.radio("Coverage:", options, key=f"rating_p1_coverage_{current_index}")
+
+        with col_p1_4:
+            persona_alignment_rating_p1 = st.radio(
+                "Persona Alignment:", options=[0, 1, 2, 3, 4],  # These are the values
+                format_func=lambda x: ["N/A", "Not Aligned", "Partially Aligned", "Aligned", "Unclear"][x],
+                key=f"rating_p1_persona_alignment_{current_index}"
+            )
+
+        # Collecting the ratings for query_p1
+        query_p1_ratings = {
+            "clarity": clarity_rating_p1,
+            "relevance": relevance_rating_p1,
+            "coverage": coverage_rating_p1,
+            "persona_alignment": persona_alignment_rating_p1
+        }
+
+        # Additional comments
+        comment = st.text_area("Additional Comments (Optional):")
+
+        # Collecting the response data
+        response = Response(
+            config_id=config["config_id"],
+            query_v=query_v_ratings,  # Use the ratings dictionary for query_v
+            query_p0=query_p0_ratings,  # Use the ratings dictionary for query_p0
+            query_p1=query_p1_ratings,  # Use the ratings dictionary for query_p1
+            comment=comment,
+            timestamp=datetime.now().isoformat()
         )
-
-    # Collecting the ratings for query_p1
-    query_p1_ratings = {
-        "clarity": clarity_rating_p1,
-        "relevance": relevance_rating_p1,
-        "coverage": coverage_rating_p1,
-        "persona_alignment": persona_alignment_rating_p1
-    }
-
-    # Additional comments
-    comment = st.text_area("Additional Comments (Optional):")
-
-    # Collecting the response data
-    response = Response(
-        config_id=config["config_id"],
-        query_v=query_v_ratings,  # Use the ratings dictionary for query_v
-        query_p0=query_p0_ratings,  # Use the ratings dictionary for query_p0
-        query_p1=query_p1_ratings,  # Use the ratings dictionary for query_p1
-        comment=comment,
-        timestamp=datetime.now().isoformat()
-    )
-
-    # Storing the response
-    print(response)
-    if len(st.session_state.responses) > current_index:
-        st.session_state.responses[current_index] = response
-    else:
-        st.session_state.responses.append(response)
-
-    # Navigation buttons
-    navigation_buttons(data, query_v_ratings["clarity"], query_p0_ratings["clarity"], query_p1_ratings["clarity"])
+        if len(st.session_state.responses) > current_index:
+            st.session_state.responses[current_index] = response
+        else:
+            st.session_state.responses.append(response)
+
+        # Navigation buttons
+        navigation_buttons(data, query_v_ratings["clarity"], query_p0_ratings["clarity"], query_p1_ratings["clarity"])
+    except IndexError:
+        print("Survey completed!")
+        # st.stop()