correct gui code

Dockerfile

@@ -17,4 +17,4 @@ EXPOSE 8501
 
 HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+ENTRYPOINT ["streamlit", "run", "src/Start_Page.py", "--server.port=8501", "--server.address=0.0.0.0"]

README.md

@@ -12,9 +12,4 @@ short_description: GUI for the QSTN Framework
 license: mit
 ---
 
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+# QSTN GUI

src/Start_Page.py

@@ -0,0 +1,60 @@
+import streamlit as st
+import pandas as pd
+from io import StringIO
+
+from qstn.survey_manager import SurveyCreator
+
+from qstn.prompt_builder import LLMPrompt
+
+st.set_page_config(layout="wide")
+st.title("Questionnaire")
+
+col1, col2 = st.columns(2)
+
+# def save_dataframe(uploaded_file):
+
+#     try:
+#         df = pd.read_csv(uploaded_file)
+#         # Store the DataFrame in session state
+#         st.session_state.df = df
+#     except Exception as e:
+#         st.error(f"Error reading the file: {e}")
+
+#     return df
+
+df_population = None
+df_questionnaire = None
+
+with col1:
+    uploaded_questionnaire = st.file_uploader("Select a questionnaire to start with")
+    if uploaded_questionnaire is not None:
+        # bytes_data = uploaded_questionnaire.getvalue()
+        # st.write(bytes_data)
+
+        df_questionnaire = pd.read_csv(uploaded_questionnaire)
+        #dataframe = save_dataframe(uploaded_questionnaire)
+
+        st.write(df_questionnaire)
+
+with col2:
+    uploaded_population = st.file_uploader("Select a population to start with")
+    if uploaded_population is not None:
+        # bytes_data = uploaded_population.getvalue()
+        # st.write(bytes_data)
+
+        df_population = pd.read_csv(uploaded_population)
+        #dataframe = save_dataframe(uploaded_population)
+
+        st.write(df_population)
+
+disabled = True
+
+if df_population is not None and df_questionnaire is not None:
+    disabled = False
+        
+st.divider()
+
+if st.button("Confirm and Prepare Questionnaire", type="primary", disabled=disabled, use_container_width=True):
+    questionnaires: list[LLMPrompt] = SurveyCreator.from_dataframe(df_population, df_questionnaire)
+    st.session_state.questionnaires = questionnaires
+    st.switch_page("pages/01_Prompt_Configuration.py")

src/gui_elements/output_manager.py

@@ -0,0 +1,61 @@
+import streamlit as st
+import io
+from contextlib import contextmanager
+import contextlib
+import re
+
+@contextmanager
+def st_capture(output_func):
+    with io.StringIO() as stdout, contextlib.redirect_stdout(stdout):
+        old_write = stdout.write
+
+        def new_write(string):
+            ret = old_write(string)
+            output_func(stdout.getvalue())
+            return ret
+
+        stdout.write = new_write
+        yield
+
+class TqdmToStreamlit(io.StringIO):
+    """
+    A custom file-like object that redirects tqdm's output to Streamlit's st.progress
+    and st.text widgets.
+    """
+    # def __init__(self, progress_bar, text_element):
+    #     super().__init__()
+    #     self.progress_bar = progress_bar
+    #     self.text_element = text_element
+    #     self.last_progress = 0
+    
+    def __init__(self, text_element):
+        super().__init__()
+        self.text_element = text_element
+
+    def write(self, buf):
+        # We can use this code if we want to have a nicer progress bar.
+        # match = re.search(r"(\d+)%\|", buf)
+        # if match:
+        #     progress = int(match.group(1))
+        #     if progress > self.last_progress:
+        #         self.progress_bar.progress(progress)
+        #         self.text_element.text(buf.strip())
+        #         self.last_progress = progress
+        self.text_element.text(buf.strip())
+
+    def flush(self):
+        pass # No-op
+
+class QueueIO(io.StringIO):
+    """
+    A custom file-like object that writes to a queue.
+    Used to capture stdout/stderr.
+    """
+    def __init__(self, q):
+        self.queue = q
+    
+    def write(self, buf):
+        self.queue.put(buf)
+
+    def flush(self):
+        pass

src/gui_elements/paginator.py

@@ -0,0 +1,68 @@
+import streamlit as st
+
+def paginator(items, session_state_key):
+    """
+    Creates a reusable paginator component for a list of items.
+
+    Args:
+        items (list): The list of items to paginate through.
+        session_state_key (str): A unique key for storing the current index in 
+                                 st.session_state.
+    
+    Returns:
+        Any: The currently selected item from the list.
+    """
+    list_length = len(items)
+    
+    # Initialize the session state for the current index if it doesn't exist.
+    if session_state_key not in st.session_state:
+        st.session_state[session_state_key] = 0
+
+    def next_item():
+        """Increments the index, wrapping around to the start if it reaches the end."""
+        if list_length > 0:
+            st.session_state[session_state_key] = (st.session_state[session_state_key] + 1) % list_length
+
+    def prev_item():
+        """Decrements the index, wrapping around to the end if it goes below zero."""
+        if list_length > 0:
+            st.session_state[session_state_key] = (st.session_state[session_state_key] - 1 + list_length) % list_length
+
+    # Create the navigation columns.
+    col1, col2, col3 = st.columns([2, 3, 2])
+
+    with col1:
+        st.button("⬅️ Previous", on_click=prev_item, use_container_width=True, disabled=(list_length <= 1))
+
+    # Display the current position and the popover for jumping to a specific item.
+    with col2:
+        if list_length > 0:
+            current_num = st.session_state[session_state_key] + 1
+            
+            popover = st.popover(f"Item {current_num} of {list_length}", use_container_width=True)
+
+            with popover:
+                st.markdown("Jump to a specific item:")
+                target_index_input = st.number_input(
+                    "Item Number",
+                    min_value=1,
+                    max_value=list_length,
+                    value=current_num,
+                    step=1,
+                    label_visibility="collapsed"
+                )
+                if st.button("Go"):
+                    st.session_state[session_state_key] = target_index_input - 1
+                    st.rerun()
+        else:
+            st.text("No items to display")
+
+    # "Next" button in the third column.
+    with col3:
+        st.button("Next ➡️", on_click=next_item, use_container_width=True, disabled=(list_length <= 1))
+
+    # Return the currently selected item.
+    if list_length > 0:
+        return st.session_state[session_state_key]
+    else:
+        return None

src/gui_elements/stateful_widget.py

@@ -0,0 +1,53 @@
+import streamlit as st
+
+class StatefulWidgets:
+    """
+    A class to create Streamlit widgets with encapsulated session state management.
+    """
+    def __init__(self, prefix: str = "_"):
+        """
+        Initializes the StatefulWidgets class.
+
+        Args:
+            prefix (str): A prefix to use for the widget's internal session state key.
+        """
+        self.prefix = prefix
+
+    def _store_value(self, key: str) -> None:
+        """
+        Callback function to store the widget's value from the internal state
+        to the main session state.
+        """
+        st.session_state[key] = st.session_state[f"{self.prefix}{key}"]
+
+    def _initialize_and_load(self, key: str, initial_value) -> None:
+        """
+        Initializes the session state for a given key if it doesn't exist,
+        and then loads this value into the widget's internal state.
+        """
+        if key not in st.session_state:
+            st.session_state[key] = initial_value
+        st.session_state[f"{self.prefix}{key}"] = st.session_state[key]
+
+    def create(self, widget_func, key: str, *args, initial_value=None, **kwargs):
+        """
+        Creates a Streamlit widget and binds its state.
+
+        Args:
+            widget_func: The Streamlit widget function (e.g., st.text_input).
+            key (str): The key for the main session state.
+            *args: Positional arguments to pass to the widget function.
+            initial_value: The initial value to set in the session state if not present.
+            **kwargs: Keyword arguments to pass to the widget function.
+
+        Returns:
+            The created Streamlit widget.
+        """
+        self._initialize_and_load(key, initial_value)
+        return widget_func(
+            *args,
+            key=f"{self.prefix}{key}",
+            on_change=self._store_value,
+            args=(key,),
+            **kwargs,
+        )

src/pages/01_Prompt_Configuration.py

@@ -0,0 +1,311 @@
+import streamlit as st
+from qstn.prompt_builder import LLMPrompt
+from qstn.utilities.constants import QuestionnairePresentation
+from qstn.utilities import placeholder
+from typing import Any
+
+from gui_elements.paginator import paginator
+from gui_elements.stateful_widget import StatefulWidgets
+
+# CONSTANTS FOR FIELDS
+question_stem_field = "Question Stem"
+randomize_order_tick = "Randomize the order of items"
+system_prompt_field = "System prompt"
+prompt_field = "Prompt"
+change_all_system_prompts_checkbox = "system_change_all"
+change_all_prompts_checkbox = "prompts_change_all"
+
+field_ids = [question_stem_field, randomize_order_tick]
+
+st.set_page_config(layout="wide")
+st.title("Prompt Configuration")
+st.write(
+    "This interface allows you configure how the questions are prompted to the LLM and the overall prompt structure. "
+    "These options are applied to every questionnaire in your survey."
+)
+st.page_link("pages/02_Option_Prompt.py", label="Click here to adjust the answer options.")
+st.divider()
+
+@st.cache_data
+def create_stateful_widget() -> StatefulWidgets:
+    return StatefulWidgets()
+
+state = create_stateful_widget()
+
+if "questionnaires" not in st.session_state:
+    st.error("You need to first upload a questionnaire and the population you want to survey.")
+    st.stop()
+    disabled = True
+else:
+    disabled = False
+
+if 'current_index' not in st.session_state:
+    st.session_state.current_index = 0
+
+#current_questionnaire_id = paginator(st.session_state.questionnaires, "current_questionnaire_index_prepare")
+current_questionnaire_id = paginator(st.session_state.questionnaires, "current_questionnaire_index_prompt")
+
+if not "temporary_questionnaire" in st.session_state:
+    st.session_state.temporary_questionnaire = st.session_state.questionnaires[0].duplicate()
+
+if not "base_questionnaire" in st.session_state:
+    st.session_state.base_questionnaire = st.session_state.temporary_questionnaire.duplicate()
+
+def process_inputs(input: Any, field_id: str) -> str:
+    if "survey_options" in st.session_state:
+        survey_options = st.session_state.survey_options
+    else:
+        survey_options = None
+
+    if field_id == question_stem_field:
+        LLMPrompt.prepare_prompt
+        st.session_state.temporary_questionnaire.prepare_prompt(
+            question_stem=input,
+            answer_options=survey_options,
+            randomized_item_order=randomize_order_bool,
+        )
+        st.session_state.base_questionnaire.prepare_prompt(
+            question_stem=input,
+            answer_options=survey_options,
+            randomized_item_order=randomize_order_bool,
+        )
+    elif field_id == randomize_order_tick:
+        if input == True:
+            st.session_state.temporary_questionnaire.prepare_prompt(
+                question_stem=question_stem_input,
+                answer_options=survey_options,
+                randomized_item_order=input,
+            )
+        else:
+            st.session_state.temporary_questionnaire = st.session_state.base_questionnaire.duplicate()
+
+def handle_change(field_id: str):
+    """
+    This single callback handles changes from any text field.
+    It reads the input from session state using the unique key,
+    processes it, and saves the output to session state.
+    """
+    input_key = f"input_{field_id}"
+
+    with st.spinner(f"Processing {field_id}..."):
+        # time.sleep(0.5) # Simulate work
+        process_inputs(st.session_state[input_key], field_id)
+
+
+if "questionnaires" in st.session_state and st.session_state.questionnaires is not None:
+    try:
+        questionnaire = st.session_state.questionnaires[current_questionnaire_id].duplicate()
+    except IndexError:
+        st.error("Index is out of range. Resetting to the first item.")
+        current_questionnaire_id = 0
+        questionnaire = st.session_state.questionnaires[current_questionnaire_id].duplicate()
+
+    col1, col2 = st.columns(2, gap="large")
+
+    with col1:
+        st.subheader("⚙️ Configuration")
+
+        for field_id in field_ids:
+            input_key = f"input_{field_id}"
+            if not input_key in st.session_state:
+                if field_id == question_stem_field:
+                    st.session_state[input_key] = st.session_state.temporary_questionnaire ._questions[0].question_stem
+                if field_id == randomize_order_tick:
+                    st.session_state[input_key] = False
+
+        # Handle placeholder replacement before widget is created
+        input_key = f"input_{question_stem_field}"
+        if "placeholder_to_replace" in st.session_state and st.session_state.placeholder_to_replace:
+            current_text = st.session_state.get(input_key, "")
+            placeholder_shortcut = st.session_state.placeholder_to_replace["shortcut"]
+            placeholder_value = st.session_state.placeholder_to_replace["value"]
+            
+            # Replace all occurrences of the shortcut (e.g., -Q) with the placeholder
+            if placeholder_shortcut in current_text:
+                st.session_state[input_key] = current_text.replace(placeholder_shortcut, placeholder_value)
+            else:
+                # Shortcut not found, append at the end
+                st.session_state[input_key] = current_text + f" {placeholder_value} "
+            
+            st.session_state.placeholder_to_replace = None
+            st.rerun()
+
+        # --- Input Widgets (No Form) ---
+        question_stem_input = st.text_area(
+            question_stem_field,
+            key=f"input_{question_stem_field}",
+            # placeholder="e.g., How would you rate the following aspects of our service?",
+            #on_change=handle_change,
+            kwargs={'field_id': question_stem_field},
+            height=100,
+        )
+
+        # --- Placeholder Replacement Buttons ---
+        st.write("**Insert Placeholder:**")
+        
+        # Define available placeholders with their shortcuts and character labels
+        # Format: (placeholder_value, shortcut, character_label, description)
+        available_placeholders = [
+            (placeholder.QUESTION_CONTENT, "-Q", "Q", "Question Content"),
+            (placeholder.PROMPT_OPTIONS, "-O", "O", "Prompt Options"),
+        ]
+        
+        # Create shortcuts list for the tip
+        shortcuts_list = ", ".join([f"`{shortcut}`" for _, shortcut, _, _ in available_placeholders])
+        st.caption(f"💡 Tip: Type shortcuts {shortcuts_list} in the text, then click the button to replace them with placeholders.")
+        
+        # Create buttons in columns with consistent formatting
+        cols = st.columns(len(available_placeholders))
+        for i, (placeholder_value, shortcut, char_label, description) in enumerate(available_placeholders):
+            button_label = description  # Use the actual placeholder name
+            button_key = f"btn_placeholder_{char_label}"
+            
+            if cols[i].button(button_label, key=button_key, use_container_width=True, help=f"Replaces '{shortcut}' with {placeholder_value}"):
+                st.session_state.placeholder_to_replace = {
+                    "shortcut": shortcut,
+                    "value": placeholder_value
+                }
+                st.rerun()
+
+        randomize_order_bool = st.checkbox(
+            randomize_order_tick,
+            key=f"input_{randomize_order_tick}",
+            value=False,
+            #on_change=handle_change,
+            kwargs={'field_id': randomize_order_tick} 
+        )
+
+        st.divider()
+
+        # System prompt and main prompt section (from Basic Prompt Settings)
+        new_system_prompt = st.text_area(
+            label=system_prompt_field,
+            key=f"{system_prompt_field}{current_questionnaire_id}",
+            value=questionnaire.system_prompt,
+            help="The system prompt the model is prompted with."
+        )
+
+        change_all_system = state.create(
+            st.checkbox,
+            key=change_all_system_prompts_checkbox,
+            label="On update: change all System Prompts",
+            help="If this is ticked, all system prompts will be changed to this.",
+            initial_value=False
+        )
+
+        # Handle placeholder replacement for main prompt before widget is created
+        prompt_key = f"{prompt_field}{current_questionnaire_id}"
+        if "main_prompt_placeholder_to_replace" in st.session_state and st.session_state.main_prompt_placeholder_to_replace:
+            current_prompt_text = st.session_state.get(prompt_key, questionnaire.prompt)
+            placeholder_shortcut = st.session_state.main_prompt_placeholder_to_replace["shortcut"]
+            placeholder_value = st.session_state.main_prompt_placeholder_to_replace["value"]
+            
+            if placeholder_shortcut in current_prompt_text:
+                st.session_state[prompt_key] = current_prompt_text.replace(placeholder_shortcut, placeholder_value)
+            else:
+                st.session_state[prompt_key] = current_prompt_text + f" {placeholder_value} "
+            
+            st.session_state.main_prompt_placeholder_to_replace = None
+            st.rerun()
+
+        new_prompt = st.text_area(
+            label=prompt_field,
+            key=prompt_key,
+            value=questionnaire.prompt,
+            help="Instructions that are given to the model before the questions."
+        )
+
+        # Placeholder insertion buttons for main prompt
+        st.write("**Insert Placeholder in Main Prompt:**")
+        main_prompt_placeholders = [
+            (placeholder.PROMPT_QUESTIONS, "-P", "P", "Prompt Questions"),
+            (placeholder.PROMPT_OPTIONS, "-O", "O", "Prompt Options"),
+            (placeholder.PROMPT_AUTOMATIC_OUTPUT_INSTRUCTIONS, "-A", "A", "Automatic Output"),
+            (placeholder.JSON_TEMPLATE, "-J", "J", "JSON Template"),
+        ]
+        
+        main_shortcuts_list = ", ".join([f"`{shortcut}`" for _, shortcut, _, _ in main_prompt_placeholders])
+        st.caption(f"💡 Tip: Type shortcuts {main_shortcuts_list} in the main prompt, then click the button to replace them.")
+        
+        cols_main = st.columns(len(main_prompt_placeholders))
+        for i, (placeholder_value, shortcut, char_label, description) in enumerate(main_prompt_placeholders):
+            button_key = f"btn_main_placeholder_{char_label}"
+            if cols_main[i].button(description, key=button_key, use_container_width=True, help=f"Replaces '{shortcut}' with {placeholder_value}"):
+                st.session_state.main_prompt_placeholder_to_replace = {
+                    "shortcut": shortcut,
+                    "value": placeholder_value
+                }
+                st.rerun()
+
+        change_all_questionnaire = state.create(
+            st.checkbox,
+            key=change_all_prompts_checkbox,
+            label="On update: change all questionnaire instructions",
+            help="If this is ticked, all questionnaire instructions will be changed to this.",
+            initial_value=False
+        )
+
+    # Place the corresponding output in the second column
+    with col2:
+        st.subheader("📄 Live Preview")
+
+    # --- The Dynamic Preview Logic ---
+    # This block re-runs on every widget interaction.
+        with st.container(border=True):
+            # Update temporary questionnaire with question stem
+            if "survey_options" in st.session_state:
+                survey_options = st.session_state.survey_options
+            else:
+                survey_options = None
+
+            if randomize_order_bool:
+                st.session_state.temporary_questionnaire.prepare_prompt(
+                    question_stem=question_stem_input,
+                    answer_options=survey_options,
+                    randomized_item_order=randomize_order_bool,
+                )
+            st.session_state.base_questionnaire.prepare_prompt(
+                question_stem=question_stem_input,
+                answer_options=survey_options,
+                randomized_item_order=False,
+            )
+
+            if not randomize_order_bool:
+                st.session_state.temporary_questionnaire = st.session_state.base_questionnaire.duplicate()
+
+            # Update system prompt and main prompt for preview (apply to temporary_questionnaire)
+            st.session_state.temporary_questionnaire.system_prompt = new_system_prompt
+            st.session_state.temporary_questionnaire.prompt = new_prompt
+            current_system_prompt, current_prompt = st.session_state.temporary_questionnaire.get_prompt_for_questionnaire_type(QuestionnairePresentation.SEQUENTIAL)
+            current_system_prompt = current_system_prompt.replace("\n", "  \n")
+            current_prompt = current_prompt.replace("\n", "  \n")
+            st.write(current_system_prompt)
+            st.write(current_prompt)
+
+    st.divider()
+
+    if st.button("Update Prompt(s)", type="secondary", use_container_width=True):
+        if change_all_system:
+            for questionnaire in st.session_state.questionnaires:
+                questionnaire.system_prompt = new_system_prompt
+        else:
+            st.session_state.questionnaires[current_questionnaire_id].system_prompt = new_system_prompt
+
+        if change_all_questionnaire:
+            for questionnaire in st.session_state.questionnaires:
+                questionnaire.prompt = new_prompt
+        else:
+            st.session_state.questionnaires[current_questionnaire_id].prompt = new_prompt             
+        st.success("Prompt(s) updated!")
+
+    if st.button("Confirm and Prepare Questionnaire", type="primary", use_container_width=True):
+        for questionnaire in st.session_state.questionnaires:
+            questionnaire.prepare_prompt(
+                question_stem=question_stem_input,
+                answer_options=survey_options,
+                randomized_item_order=randomize_order_bool,
+            )
+        st.success("Changed the prompts!")
+        st.switch_page("pages/02_Option_Prompt.py")
+else:
+    st.warning("No data found. Please upload a CSV file on the 'Start Page' first.")

src/pages/02_Option_Prompt.py

@@ -0,0 +1,197 @@
+import streamlit as st
+from qstn.prompt_builder import LLMPrompt, generate_likert_options
+from qstn.utilities.prompt_templates import (
+    LIST_OPTIONS_DEFAULT,
+    SCALE_OPTIONS_DEFAULT,
+)
+
+from gui_elements.stateful_widget import StatefulWidgets
+
+st.set_page_config(layout="wide")
+st.title("Likert Scale Options Generator")
+st.write(
+    "This interface allows you to configure and generate Likert scale answer options by adjusting the parameters below."
+)
+st.divider()
+
+if "questionnaires" not in st.session_state:
+    st.error("You need to first upload a questionnaire and the population you want to survey.")
+    st.stop()
+    disabled = True
+else:
+    disabled = False
+
+#if 'answer_texts_input' not in st.session_state:
+    #st.session_state.answer_texts_input = "Strongly Disagree\nDisagree\nNeutral\nAgree\nStrongly Agree"
+
+state = StatefulWidgets()
+
+# Use a form to batch all inputs together
+with st.container(border=True):
+    # --- Main Configuration ---
+    st.subheader("Main Configuration")
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        n_options = state.create(
+            st.number_input,
+            "n_options",
+            "Number of Options (n)",
+            initial_value=5,
+            min_value=2,
+            step=1,
+            help="The total number of choices in the scale.",
+        )
+
+    with col2:
+        idx_type = state.create(
+            st.selectbox,
+            "idx_type",
+            "Index Type",
+            initial_value="integer",
+            options=["integer", "char_low", "char_up"],
+            help="The type of index to use for the options.",
+        )
+
+    with col3:
+        start_idx = state.create(
+            st.number_input,
+            "start_idx",
+            "Starting Index",
+            initial_value=1,
+            step=1,
+            help="The number to start counting from (e.g., 1).",
+        )
+
+    # --- Order and Structure Options ---
+    st.subheader("Ordering and Structure")
+    col1, col2, col3, col4 = st.columns(4)
+
+    with col1:
+        only_from_to_scale = state.create(
+            st.checkbox,
+            "only_from_to_scale",
+            "From-To Scale Only",
+            initial_value=False,
+            help="If checked, only the first and last answer labels are display e.g. 1 Strongly Disagree to 5 Strongly agree.",
+        )
+
+    with col2:
+        random_order = state.create(
+            st.checkbox,
+            "random_order",
+            "Random Order",
+            initial_value=False,
+            help="Randomize the order of options.",
+        )
+
+    with col3:
+        reversed_order = state.create(
+            st.checkbox,
+            "reversed_order",
+            "Reversed Order",
+            initial_value=False,
+            help="Reverse the order of options.",
+        )
+
+    with col4:
+        even_order = state.create(
+            st.checkbox,
+            "even_order",
+            "Even Order",
+            initial_value=False,
+            help="If there is an uneven number of answer texts, the middle section is automatically removed.",
+        )
+
+    # --- Answer Texts Input ---
+    st.subheader("Answer Texts")
+
+    answer_texts = state.create(
+        st.text_area,
+        "answer_texts",
+        "Enter Answer Texts (one per line)",
+        initial_value="Strongly Disagree\nDisagree\nNeutral\nAgree\nStrongly Agree",
+        height=150,
+        help="Enter the labels for each answer option.",
+    )
+
+    # --- Advanced Configuration ---
+    with st.expander("Advanced Configuration"):
+        options_separator = state.create(
+            st.text_input,
+            "options_separator",
+            "Options Separator",
+            initial_value=", ",
+            help="The character(s) used to separate options in the final string.",
+        )
+        list_prompt_template = state.create(
+            st.text_area,
+            "list_prompt_template",
+            "List Prompt Template",
+            initial_value=LIST_OPTIONS_DEFAULT,
+            height=100,
+            help="Write how the options should be presented to the model.",
+        )
+        scale_prompt_template = state.create(
+            st.text_area,
+            "scale_prompt_template",
+            "Scale Prompt Template",
+            initial_value=SCALE_OPTIONS_DEFAULT,
+            height=100,
+            help="Write how the options should be presented to the model.",
+        )
+
+
+    # The submit button for the form
+    submitted = st.button("Confirm and Generate Options", disabled=disabled, type="primary", use_container_width=True)
+
+    if st.button("Remove all options", use_container_width=True, icon="❌"):
+        st.session_state.survey_options = None
+        st.switch_page("pages/03_Inference_Setting.py")
+
+# --- Processing and Output ---
+if submitted:
+    #print("Session state answer texts "+ st.session_state.answer_texts_input)
+    #print(answer_texts_input)
+    # Convert the raw text area string into a list of strings.
+    answer_texts_list = [
+        text.strip() for text in answer_texts.split("\n") if text.strip()
+    ]
+
+    # --- Input Validation ---
+    validation_ok = True
+    if only_from_to_scale and len(answer_texts_list) != 2:
+        st.error(
+            f"Error: When 'From-To Scale Only' is selected, you must provide exactly 2 answer texts. You provided {len(answer_texts_list)}."
+        )
+        validation_ok = False
+
+    if not only_from_to_scale and len(answer_texts_list) != n_options:
+        st.error(
+            f"Error: The number of answer texts ({len(answer_texts_list)}) must match the 'Number of Options' ({n_options})."
+        )
+        validation_ok = False
+
+    if reversed_order and random_order:
+        st.error(f"Error: Reversed Order and Random Order cannot both be true.")
+        validation_ok = False
+
+    if validation_ok:
+        survey_options = generate_likert_options(
+            n=n_options,
+            answer_texts=answer_texts_list,
+            only_from_to_scale=only_from_to_scale,
+            random_order=random_order,
+            reversed_order=reversed_order,
+            even_order=even_order,
+            start_idx=start_idx,
+            list_prompt_template=list_prompt_template,
+            scale_prompt_template=scale_prompt_template,
+            options_separator=options_separator,
+            idx_type=idx_type,
+        )
+
+        st.session_state.survey_options = survey_options
+        st.switch_page("pages/03_Inference_Setting.py")
+
+

src/pages/03_Inference_Setting.py

@@ -0,0 +1,230 @@
+import streamlit as st
+import json
+from gui_elements.stateful_widget import StatefulWidgets
+
+# --- Page Configuration ---
+st.set_page_config(
+    page_title="Inference Settings",
+    layout="wide"
+)
+
+st.title("AsyncOpenAI API Client & Inference Configurator")
+st.markdown("Use the widgets below to configure the `AsyncOpenAI` client and the inference parameters for an API call. Advanced or less common options can be added as a JSON object.")
+
+st.divider()
+
+# --- Column Layout ---
+col1, col2 = st.columns(2)
+
+defaults = {
+    # Client Config
+    "api_key": "", "organization": "", "project": "", "base_url": "",
+    "timeout": 20, "max_retries": 2,
+    "advanced_client_params_str": '',
+    # Inference Config
+    "model_name": "", "temperature": 1.0, "max_tokens": 1024,
+    "top_p": 1.0, "seed": 42,
+    "advanced_inference_params_str": ''
+}
+
+for key, value in defaults.items():
+    if key not in st.session_state:
+        st.session_state[key] = value
+
+
+state = StatefulWidgets()
+
+# ==============================================================================
+# COLUMN 1: OPENAI CLIENT CONFIGURATION
+# ==============================================================================
+with col1:
+    st.header("1. Client Configuration")
+
+with col2:
+    st.header("2. Inference Configuration")
+
+with col1:
+    with st.container(border=True):
+        st.subheader("Core Settings")
+
+        api_key = state.create(
+            st.text_input,
+            "api_key",
+            "API Key",
+            initial_value="",
+            type="password",
+            placeholder="sk-...",
+            help="Your OpenAI API key. It is handled securely by Streamlit."
+        )
+
+        organization = state.create(
+            st.text_input,
+            "organization",
+            "Organization ID",
+            initial_value="",
+            placeholder="org-...",
+            help="Optional identifier for your organization."
+        )
+
+        project = state.create(
+            st.text_input,
+            "project",
+            "Project ID",
+            initial_value="",
+            placeholder="proj_...",
+            help="Optional identifier for your project."
+        )
+
+        base_url = state.create(
+            st.text_input,
+            "base_url",
+            "Base URL",
+            initial_value="",
+            placeholder="https://api.openai.com/v1",
+            help="The base URL for the API. Leave empty for the default."
+        )
+
+        timeout = state.create(
+            st.number_input,
+            "timeout",
+            "Timeout (seconds)",
+            initial_value=20,
+            min_value=1,
+            help="The timeout for API requests in seconds."
+        )
+
+        max_retries = state.create(
+            st.number_input,
+            "max_retries",
+            "Max Retries",
+            initial_value=2,
+            min_value=0,
+            help="The maximum number of times to retry a failed request."
+        )
+
+        with st.expander("Advanced Client Settings (JSON)"):
+            advanced_client_params_str = state.create(
+                st.text_area,
+                "advanced_client_params_str",
+                "JSON for other client parameters",
+                initial_value="",
+                placeholder='{\n  "default_headers": {"X-Custom-Header": "value"}\n}',
+                height=150,
+                help='Enter any other client init parameters like "default_headers" or "default_query" as a valid JSON object.'
+            )
+
+# ==============================================================================
+# COLUMN 2: INFERENCE PARAMETERS
+# ==============================================================================
+
+with col2:
+    with st.container(border=True):
+        st.subheader("Core Settings")
+        model_name = state.create(
+            st.text_input,
+            "model_name",
+            "Model Name",
+            #initial_value="meta-llama/Llama-3.1-70B-Instruct",
+            placeholder="meta-llama/Llama-3.1-70B-Instruct",
+            help="The model to use for the inference call."
+        )
+
+        temperature = state.create(
+            st.slider,
+            "temperature",
+            "Temperature",
+            min_value=0.0,
+            max_value=2.0,
+            step=0.01,
+            initial_value=1.0,
+            help="Controls randomness. Lower values are more deterministic and less creative."
+        )
+
+        max_tokens = state.create(
+            st.number_input,
+            "max_tokens",
+            "Max Tokens",
+            initial_value=1024,
+            min_value=1,
+            help="The maximum number of tokens to generate in the completion."
+        )
+
+        top_p = state.create(
+            st.slider,
+            "top_p",
+            "Top P",
+            min_value=0.0,
+            max_value=1.0,
+            step=0.01,
+            initial_value=1.0,
+            help="Controls nucleus sampling. The model considers tokens with top_p probability mass."
+        )
+
+        seed = state.create(
+            st.number_input,
+            "seed",
+            "Seed",
+            initial_value=42,
+            min_value=0,
+            help="A specific seed for reproducibility of results."
+        )
+
+        with st.expander("Advanced Inference Settings (JSON)"):
+            advanced_inference_params_str = state.create(
+                st.text_area,
+                "advanced_inference_params_str",
+                "JSON for other inference parameters",
+                initial_value="",
+                placeholder='{\n  "stop": ["\\n", " Human:"],\n  "presence_penalty": 0\n}',
+                height=150,
+                help='Enter any other valid inference parameters like "stop", "logit_bias", or "frequency_penalty" as a JSON object.'
+            )
+
+
+# ==============================================================================
+# GENERATION AND DISPLAY LOGIC
+# ==============================================================================
+st.divider()
+
+if st.button("Generate Configuration & Code", type="primary", use_container_width=True):
+    # --- Process Client Config ---
+    client_config = {
+        "api_key": api_key
+    }
+    # Add optional string parameters if they are not empty
+    if organization: client_config["organization"] = organization
+    if project: client_config["project"] = project
+    if base_url: client_config["base_url"] = base_url
+    # Add numeric parameters
+    client_config["timeout"] = timeout
+    client_config["max_retries"] = max_retries
+
+    try:
+        if advanced_client_params_str:
+            advanced_client_params = json.loads(advanced_client_params_str)
+            client_config.update(advanced_client_params)
+    except json.JSONDecodeError:
+        st.error("Invalid JSON detected in Advanced Client Settings. Please correct it.")
+        st.stop()
+
+    # --- Process Inference Config ---
+    inference_config = {
+        "model": model_name,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "top_p": top_p,
+        "seed": seed
+    }
+
+    try:
+        if advanced_inference_params_str:
+            advanced_inference_params = json.loads(advanced_inference_params_str)
+            inference_config.update(advanced_inference_params)
+    except json.JSONDecodeError:
+        st.error("Invalid JSON detected in Advanced Inference Settings. Please correct it.")
+        st.stop()
+
+    st.session_state.client_config = client_config
+    st.session_state.inference_config = inference_config
+
+    st.success("Configuration generated successfully!")

src/pages/04_Final_Overview.py

@@ -0,0 +1,289 @@
+import streamlit as st
+from gui_elements.paginator import paginator
+from gui_elements.stateful_widget import StatefulWidgets
+from gui_elements.output_manager import st_capture, TqdmToStreamlit
+
+import io
+import queue
+import time
+import threading
+import asyncio
+
+import logging
+
+from contextlib import redirect_stderr, redirect_stdout
+
+from qstn.parser.llm_answer_parser import raw_responses
+from qstn.utilities.constants import QuestionnairePresentation
+from qstn.utilities.utils import create_one_dataframe
+from qstn.survey_manager import (
+    conduct_survey_sequential,
+    conduct_survey_battery,
+    conduct_survey_single_item,
+)
+
+from streamlit.runtime.scriptrunner import add_script_run_ctx
+
+from openai import AsyncOpenAI
+
+# Set OpenAI's API key and API base to use vLLM's API server.
+
+
+if "questionnaires" not in st.session_state:
+    st.error(
+        "You need to first upload a questionnaire and the population you want to survey."
+    )
+    st.stop()
+    disabled = True
+else:
+    disabled = False
+
+
+@st.cache_data
+def create_stateful_widget() -> StatefulWidgets:
+    return StatefulWidgets()
+
+
+state = create_stateful_widget()
+
+current_index = paginator(st.session_state.questionnaires, "overview_page")
+
+questionnaires = st.session_state.questionnaires[current_index]
+
+col_llm, col_prompt_display = st.columns(2)
+
+with col_llm:
+    st.subheader("⚙️ Inference Parameters")
+
+    with st.container(border=True):
+        st.subheader("Core Settings")
+        model_name = state.create(
+            st.text_input,
+            "model_name",
+            "Model Name",
+            # initial_value="meta-llama/Llama-3.1-70B-Instruct",
+            # placeholder="meta-llama/Llama-3.1-70B-Instruct",
+            disabled=True,
+            help="The model to use for the inference call.",
+        )
+
+        temperature = state.create(
+            st.slider,
+            "temperature",
+            "Temperature",
+            min_value=0.0,
+            max_value=2.0,
+            step=0.01,
+            initial_value=1.0,
+            disabled=True,
+            help="Controls randomness. Lower values are more deterministic and less creative.",
+        )
+
+        max_tokens = state.create(
+            st.number_input,
+            "max_tokens",
+            "Max Tokens",
+            initial_value=1024,
+            min_value=1,
+            disabled=True,
+            help="The maximum number of tokens to generate in the completion.",
+        )
+
+        top_p = state.create(
+            st.slider,
+            "top_p",
+            "Top P",
+            min_value=0.0,
+            max_value=1.0,
+            step=0.01,
+            initial_value=1.0,
+            disabled=True,
+            help="Controls nucleus sampling. The model considers tokens with top_p probability mass.",
+        )
+
+        seed = state.create(
+            st.number_input,
+            "seed",
+            "Seed",
+            initial_value=42,
+            min_value=0,
+            disabled=True,
+            help="A specific seed for reproducibility of results.",
+        )
+
+        with st.expander("Advanced Inference Settings (JSON)"):
+            advanced_inference_params_str = state.create(
+                st.text_area,
+                "advanced_inference_params_str",
+                "JSON for other inference parameters",
+                initial_value="",
+                # placeholder='{\n  "stop": ["\\n", " Human:"],\n  "presence_penalty": 0\n}',
+                height=150,
+                disabled=True,
+                help='Enter any other valid inference parameters like "stop", "logit_bias", or "frequency_penalty" as a JSON object.',
+            )
+
+
+with col_prompt_display:
+    st.subheader("📄 Live Preview")
+    
+    # Survey method selector
+    survey_method_options = {
+        "Single item": ("single_item", QuestionnairePresentation.SINGLE_ITEM),
+        "Battery": ("battery", QuestionnairePresentation.BATTERY),
+        "Sequential": ("sequential", QuestionnairePresentation.SEQUENTIAL),
+    }
+    
+    survey_method_display = state.create(
+        st.selectbox,
+        "survey_method",
+        "Questionnaire Method",
+        options=list(survey_method_options.keys()),
+        initial_value="Single item",
+        help="Choose how to conduct the questionnaire: Single item (one at a time), Battery (all questions together), or Sequential (with conversation history)."
+    )
+    
+    # Get the method name and questionnaire type from selection
+    selected_method_name, selected_questionnaire_type = survey_method_options[survey_method_display]
+
+    with st.container(border=True):
+        current_system_prompt, current_prompt = questionnaires.get_prompt_for_questionnaire_type(selected_questionnaire_type)
+        current_system_prompt = current_system_prompt.replace("\n", "  \n")
+        current_prompt = current_prompt.replace("\n", "  \n")
+        st.write(current_system_prompt)
+        st.write(current_prompt)
+
+model_name = state.create(
+    st.text_input,
+    "save_file",
+    "Save File",
+    # initial_value="meta-llama/Llama-3.1-70B-Instruct",
+    # placeholder="meta-llama/Llama-3.1-70B-Instruct",
+    help="The save file to write your results to. Should be a csv file.",
+)
+
+
+if st.button("Confirm and Run Questionnaire", type="primary", use_container_width=True):
+    st.write("Starting inference...")
+
+    openai_api_key = "EMPTY"
+    openai_api_base = "http://localhost:8000/v1"
+
+    client = AsyncOpenAI(**st.session_state.client_config)
+
+    inference_config = st.session_state.inference_config.copy()
+
+    model_name = inference_config.pop("model")
+
+    progress_text = st.empty()
+
+    log_queue = queue.Queue()
+    result_queue = queue.Queue()
+
+    class QueueWriter:
+        def __init__(self, q):
+            self.q = q
+
+        def write(self, message):
+            if message.strip():
+                self.q.put(message)
+
+        def flush(self):
+            # This function is needed to match the file-like object interface
+            # but we don't need to do anything here.
+            pass
+
+    # Helper function for asyncronous runs
+    def run_async_in_thread(
+        result_q, client, questionnaires, model_name, survey_method_name, **inference_config
+    ):
+        queue_writer = QueueWriter(log_queue)
+
+        # We need to redirect the output to a queue, as streamlit does not support multithreading
+        # API concurrency should be  configurable in the GUI
+        try:
+            with redirect_stderr(queue_writer):
+                # Select the appropriate survey method based on user choice
+                if survey_method_name == "single_item":
+                    survey_func = conduct_survey_single_item
+                elif survey_method_name == "battery":
+                    survey_func = conduct_survey_battery
+                elif survey_method_name == "sequential":
+                    survey_func = conduct_survey_sequential
+                else:
+                    survey_func = conduct_survey_single_item  # Default fallback
+                
+                result = survey_func(
+                    client,
+                    llm_prompts=questionnaires,
+                    client_model_name=model_name,
+                    api_concurrency=100,
+                    **inference_config,
+                )
+
+        except Exception as e:
+            result = e
+            st.error(e)
+        finally:
+            result_q.put(result)
+
+    while not log_queue.empty():
+        log_queue.get()
+    while not result_queue.empty():
+        result_queue.get()  
+
+    # Get the selected survey method
+    survey_method_display = st.session_state.get("survey_method", "Single item")
+    survey_method_options = {
+        "Single item": ("single_item", QuestionnairePresentation.SINGLE_ITEM),
+        "Battery": ("battery", QuestionnairePresentation.BATTERY),
+        "Sequential": ("sequential", QuestionnairePresentation.SEQUENTIAL),
+    }
+    selected_method_name, _ = survey_method_options.get(survey_method_display, ("single_item", QuestionnairePresentation.SINGLE_ITEM))
+    
+    thread = threading.Thread(
+        target=run_async_in_thread,
+        args=(result_queue, client, st.session_state.questionnaires, model_name, selected_method_name),
+        kwargs=inference_config,
+    )
+    thread.start()
+
+    all_questions_placeholder = st.empty()
+    progress_placeholder = st.empty()
+
+    while thread.is_alive():
+        try:
+            # Here we can write directly to the UI, as it is the main thread
+            # TQDM uses carriage returns (\r) to animate in the console, we only show clear lines
+            log_message = log_queue.get_nowait()
+            # This is quite a hacky solution for now, we should adjust QSTN to make the messages clearly parsable.
+            if "[A" not in log_message and "Processing Prompts" not in log_message:
+                all_questions_placeholder.text(log_message.strip().replace("\r", ""))
+
+            elif "Processing Prompts" in log_message:
+                progress_placeholder.text(log_message.strip().replace("\r", ""))
+
+        except queue.Empty:
+            pass
+        time.sleep(0.1)
+    thread.join()
+
+    all_questions_placeholder.empty()
+    progress_placeholder.empty()
+
+    try:
+        final_output = result_queue.get_nowait()
+    except queue.Empty:
+        st.error("Could not retrieve result from the asynchronous task.")
+
+    st.success("Finished inferencing! Saving results...")
+
+    responses = raw_responses(final_output)
+
+    df = create_one_dataframe(responses)
+
+    st.dataframe(df)
+
+    df.to_csv(st.session_state.save_file, index=False)
+
+    st.success(f"File saved to {st.session_state.save_file}!")

src/pages/old_pages/_01_Basic_Prompt_Settings.py

@@ -0,0 +1,124 @@
+import streamlit as st
+from qstn.llm_questionnaire import LLMQuestionnaire
+from qstn.survey_manager import conduct_survey_single_item, conduct_survey_sequential, conduct_survey_battery, SurveyOptionGenerator, SurveyCreator
+from qstn.utilities.constants import QuestionnaireType
+from gui_elements.paginator import paginator
+from gui_elements.stateful_widget import StatefulWidgets
+import time
+
+
+#CONSTANTS FOR FIELDS
+system_prompt_field = "System prompt"
+prompt_field = "Prompt"
+change_all_system_prompts_checkbox = "system_change_all"
+change_all_prompts_checkbox = "prompts_change_all"
+
+st.set_page_config(layout="wide")
+st.title("Generate Prompt")
+st.write(
+    "This interface allows you to inspect and change the system prompt and primary instructions for the model."
+)
+st.divider()
+
+
+@st.cache_data
+def create_stateful_widget() -> StatefulWidgets:
+    return StatefulWidgets()
+
+state = create_stateful_widget()
+
+#FOR DEBUGGING
+# if "questionnaires" not in st.session_state:
+#     st.session_state.questionnaires = [SurveyCreator().from_path(survey_path="/home/maxi/Documents/SurveyGen/surveys/ANES.csv", questionnaire_path="/home/maxi/Documents/SurveyGen/surveys/ANES_PERSONAS.csv")]
+if "questionnaires" not in st.session_state:
+    st.error("You need to first upload a questionnaire and the population you want to survey.")
+    st.stop()
+
+if 'current_index' not in st.session_state:
+    st.session_state.current_index = 0
+
+text_field_ids = [system_prompt_field, prompt_field]
+
+current_questionnaire_id = paginator(st.session_state.questionnaires, "current_questionnaire_index_prompt")
+
+st.divider()
+
+if "questionnaires" in st.session_state and st.session_state.questionnaires is not None:
+    try:
+        questionnaire = st.session_state.questionnaires[current_questionnaire_id].duplicate()
+    except IndexError:
+        st.error("Index is out of range. Resetting to the first item.")
+        current_questionnaire_id = 0
+        questionnaire = st.session_state.questionnaires[current_questionnaire_id].duplicate()
+        
+    #st.session_state.preview_questionnaire = questionnaire
+
+    col_options, col_prompt_display = st.columns(2)
+
+    with col_options:
+        st.subheader("⚙️ Configuration")
+
+        new_system_prompt = st.text_area(
+            label=system_prompt_field,
+            key=f"{system_prompt_field}{current_questionnaire_id}",
+            value=questionnaire.system_prompt,
+            help="The system prompt the model is prompted with."
+        )
+
+        change_all_system = state.create(
+            st.checkbox,
+            key=change_all_system_prompts_checkbox,
+            label="On update: change all System Prompts",
+            help="If this is ticked, all system prompts will be changed to this.",
+            initial_value=False
+        )
+
+        new_prompt = st.text_area(
+            label=prompt_field,
+            key=f"{prompt_field}{current_questionnaire_id}",
+            value=questionnaire.prompt,
+            help="Instructions that are given to the model before the questions."
+        )
+
+        change_all_questionnaire = state.create(
+            st.checkbox,
+            key=change_all_prompts_checkbox,
+            label="On update: change all questionnaire instructions",
+            help="If this is ticked, all questionnaire instructions will be changed to this.",
+            initial_value=False
+        )
+
+    # Place the corresponding output in the second column
+    with col_prompt_display:
+        st.subheader("📄 Live Preview")
+
+    # --- The Dynamic Preview Logic ---
+    # This block re-runs on every widget interaction.
+        with st.container(border=True):
+            questionnaire.system_prompt = new_system_prompt
+            questionnaire.prompt = new_prompt
+            current_system_prompt, current_prompt = questionnaire.get_prompt_for_questionnaire_type(QuestionnaireType.SEQUENTIAL)
+            current_system_prompt = current_system_prompt.replace("\n", "  \n")
+            current_prompt = current_prompt.replace("\n", "  \n")
+            st.write(current_system_prompt)
+            st.write(current_prompt)
+    if st.button("Update Prompt(s)", type="secondary", use_container_width=True):
+        if change_all_system:
+            for questionnaire in st.session_state.questionnaires:
+                questionnaire.system_prompt = new_system_prompt
+        else:
+            st.session_state.questionnaires[current_questionnaire_id].system_prompt = new_system_prompt
+
+        if change_all_questionnaire:
+            for questionnaire in st.session_state.questionnaires:
+                questionnaire.prompt = new_prompt
+        else:
+            st.session_state.questionnaires[current_questionnaire_id].prompt = new_prompt             
+        st.success("Prompt(s) updated!")
+
+    if st.button("Confirm Base Prompt", type="primary", use_container_width=True):
+        st.switch_page("pages/02_Option_Prompt.py")
+else:
+    st.warning("No data found. Please upload a CSV file on the 'Start Page' first.")
+
+

src/pages/old_pages/_03_Prepare_Prompts.py

@@ -0,0 +1,178 @@
+import streamlit as st
+from qstn.survey_manager import SurveyOptionGenerator
+from qstn.llm_questionnaire import LLMQuestionnaire
+from qstn.utilities.constants import QuestionnaireType
+from typing import Any
+
+from gui_elements.paginator import paginator
+
+# CONSTANTS FOR FIELDS
+question_stem_field = "Question Stem"
+randomize_order_tick = "Randomize the order of items"
+
+field_ids = [question_stem_field, randomize_order_tick]
+
+st.title("Questions Preparation")
+st.write(
+    "This interface allows you configure how the questions are prompted to the LLM. These options are applied to every questionnaire in your survey."
+)
+st.page_link("pages/02_Option_Prompt.py", label="Click here to adjust the answer options.")
+st.divider()
+
+#current_questionnaire_id = paginator(st.session_state.questionnaires, "current_questionnaire_index_prepare")
+
+if "questionnaires" not in st.session_state:
+    st.error("You need to first upload a questionnaire and the population you want to survey.")
+    st.stop()
+    disabled = True
+else:
+    disabled = False
+if not "temporary_questionnaire" in st.session_state:
+    st.session_state.temporary_questionnaire = st.session_state.questionnaires[0].duplicate()
+
+    #print(st.session_state.temporary_questionnaire._questions)
+
+if not "base_questionnaire" in st.session_state:
+    st.session_state.base_questionnaire = st.session_state.temporary_questionnaire.duplicate()
+
+def process_inputs(input: Any, field_id: str) -> str:
+    if "survey_options" in st.session_state:
+        survey_options = st.session_state.survey_options
+    else:
+        survey_options = None
+
+    if field_id == question_stem_field:
+        LLMQuestionnaire.prepare_questionnaire
+        st.session_state.temporary_questionnaire.prepare_questionnaire(
+            question_stem=input,
+            answer_options=survey_options,
+            randomized_item_order=randomize_order_bool,
+        )
+        st.session_state.base_questionnaire.prepare_questionnaire(
+            question_stem=input,
+            answer_options=survey_options,
+            randomized_item_order=randomize_order_bool,
+        )
+    # elif field_id == global_options_tick:
+    #     option_behavior = input == "Give instruction in the beginning"
+    #     st.session_state.temporary_questionnaire.prepare_questionnaire(
+    #         question_stem=question_stem_input,
+    #         answer_options=survey_options,
+    #         global_options=option_behavior,
+    #         randomized_item_order=randomize_order_bool,
+    #     )
+    #     st.session_state.base_questionnaire.prepare_questionnaire(
+    #         question_stem=question_stem_input,
+    #         answer_options=survey_options,
+    #         global_options=option_behavior,
+    #         randomized_item_order=False,
+    #     )
+    elif field_id == randomize_order_tick:
+        if input == True:
+            st.session_state.temporary_questionnaire.prepare_questionnaire(
+                question_stem=question_stem_input,
+                answer_options=survey_options,
+                randomized_item_order=input,
+            )
+        else:
+            st.session_state.temporary_questionnaire = st.session_state.base_questionnaire.duplicate()
+
+def handle_change(field_id: str):
+    """
+    This single callback handles changes from any text field.
+    It reads the input from session state using the unique key,
+    processes it, and saves the output to session state.
+    """
+    input_key = f"input_{field_id}"
+
+    with st.spinner(f"Processing {field_id}..."):
+        # time.sleep(0.5) # Simulate work
+        process_inputs(st.session_state[input_key], field_id)
+
+
+col1, col2 = st.columns(2, gap="large")
+
+with col1:
+    st.subheader("⚙️ Configuration")
+
+    for field_id in field_ids:
+        input_key = f"input_{field_id}"
+        if not input_key in st.session_state:
+            if field_id == question_stem_field:
+                st.session_state[input_key] = st.session_state.temporary_questionnaire ._questions[0].question_stem
+            if field_id == randomize_order_tick:
+                st.session_state[input_key] = False
+
+    # --- Input Widgets (No Form) ---
+    question_stem_input = st.text_area(
+        question_stem_field,
+        key=f"input_{question_stem_field}",
+        # placeholder="e.g., How would you rate the following aspects of our service?",
+        #on_change=handle_change,
+        kwargs={'field_id': question_stem_field},
+        height=100,
+    )
+
+    # option_behavior = st.radio(
+    #     global_options_tick,
+    #     key=f"input_{global_options_tick}",
+    #     options=[
+    #         "Give instruction in the beginning",
+    #         "Give options after each question",
+    #     ],
+    #     index=0,
+    #     #on_change=handle_change,
+    #     kwargs={'field_id': global_options_tick},
+    #     help="Choose how answer options are applied.",
+    # )
+
+    randomize_order_bool = st.checkbox(
+        randomize_order_tick,
+        key=f"input_{randomize_order_tick}",
+        value=False,
+        #on_change=handle_change,
+        kwargs={'field_id': randomize_order_tick} 
+    )
+
+if "survey_options" in st.session_state:
+    survey_options = st.session_state.survey_options
+else:
+    survey_options = None
+
+if randomize_order_bool:
+    st.session_state.temporary_questionnaire.prepare_questionnaire(
+        question_stem=question_stem_input,
+        answer_options=survey_options,
+        randomized_item_order=randomize_order_bool,
+    )
+st.session_state.base_questionnaire.prepare_questionnaire(
+    question_stem=question_stem_input,
+    answer_options=survey_options,
+    randomized_item_order=False,
+)
+
+if not randomize_order_bool:
+    st.session_state.temporary_questionnaire = st.session_state.base_questionnaire.duplicate()
+
+with col2:
+    st.subheader("📄 Live Preview")
+
+    #@Ahmed All of these could be a resusable function (it is used on almost all pages) Maybe split up the container in system prompt/ prompt
+    with st.container(border=True):
+        system_prompt, current_prompt = st.session_state.temporary_questionnaire.get_prompt_for_questionnaire_type(QuestionnaireType.BATTERY)
+        # markdown newlines
+        system_prompt = system_prompt.replace("\n", "  \n")
+        current_prompt = current_prompt.replace("\n", "  \n")
+        st.write(system_prompt)
+        st.write(current_prompt)
+
+st.divider()
+
+if st.button("Confirm and Prepare Questionnaire", type="primary", use_container_width=True):
+    for questionnaire in st.session_state.questionnaires:
+        questionnaire.prepare_questionnaire(
+            question_stem=question_stem_input,
+            answer_options=survey_options,
+            randomized_item_order=randomize_order_bool,
+        )
+    st.success("Changed the prompts!")

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))

src/surveyGenGui.egg-info/PKG-INFO

@@ -0,0 +1,3 @@
+Metadata-Version: 2.4
+Name: surveyGenGui
+Version: 0.0.1

src/surveyGenGui.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+pyproject.toml
+src/Start_Page.py
+src/__init__.py
+src/gui_elements/__init__.py
+src/gui_elements/output_manager.py
+src/gui_elements/paginator.py
+src/gui_elements/stateful_widget.py
+src/pages/01_Basic_Prompt_Settings.py
+src/pages/02_Option_Prompt.py
+src/pages/03_Prepare_Prompts.py
+src/pages/04_Inference_Setting.py
+src/pages/05_Final_Overview.py
+src/pages/__init__.py
+src/surveyGenGui.egg-info/PKG-INFO
+src/surveyGenGui.egg-info/SOURCES.txt
+src/surveyGenGui.egg-info/dependency_links.txt
+src/surveyGenGui.egg-info/top_level.txt

src/surveyGenGui.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

src/surveyGenGui.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+Start_Page
+__init__
+gui_elements
+pages