Fixed some Streamlit related bugs.

Dockerfile

@@ -38,10 +38,11 @@ RUN poetry install --with=dev
 
 COPY meta_prompt /app/meta_prompt/
 COPY app /app/app/
+COPY app.py /app/app.py
 RUN poetry install --with=dev
 
 # Expose the Streamlit default port
 EXPOSE 8501
 
 # Run the Streamlit script when the container launches
-CMD ["streamlit", "run", "app/streamlit_sample_generator.py"]
+CMD ["streamlit", "run", "app.py"]

app/streamlit_meta_prompt.py

@@ -462,8 +462,8 @@ with st.sidebar:
     aggressive_exploration_input = st.checkbox("Aggressive Exploration", False)
 
 # Initialize session state
-if 'meta_prompt_input_data' not in st.session_state:
-    st.session_state.meta_prompt_input_data = pd.DataFrame(columns=["Input", "Output"])
+if 'shared_input_data' not in st.session_state:
+    st.session_state.shared_input_data = pd.DataFrame(columns=["Input", "Output"])
 if 'initial_system_message' not in st.session_state:
     st.session_state.initial_system_message = ""
 if 'initial_acceptance_criteria' not in st.session_state:
@@ -480,15 +480,13 @@ if 'chat_log' not in st.session_state:
     st.session_state.chat_log = []
 
 def copy_system_message():
-    if 'system_message_output' in st.session_state:
-        st.session_state.initial_system_message = st.session_state.system_message_output
+    st.session_state.initial_system_message = system_message_output
 
 def copy_acceptance_criteria():
-    if 'acceptance_criteria_output' in st.session_state:
-        st.session_state.initial_acceptance_criteria = st.session_state.acceptance_criteria_output
+    st.session_state.initial_acceptance_criteria = acceptance_criteria_output
 
 def clear_session_state():
-    st.session_state.meta_prompt_input_data = pd.DataFrame(columns=["Input", "Output"])
+    st.session_state.shared_input_data = pd.DataFrame(columns=["Input", "Output"])
     st.session_state.initial_system_message = ""
     st.session_state.initial_acceptance_criteria = ""
     st.session_state.system_message_output = ""
@@ -498,7 +496,82 @@ def clear_session_state():
     st.session_state.chat_log = []
 
 def sync_input_data():
-    st.session_state.sample_generator_input_data = data_editor_data.copy()
+    st.session_state.shared_input_data = data_editor_data.copy()
+
+def pull_sample_description():
+    if 'description_output_text' in st.session_state:
+        st.session_state.initial_system_message = st.session_state.description_output_text
+
+def generate_callback():
+    try:
+        first_input_key = data_editor_data["Input"].first_valid_index()
+        first_output_key = data_editor_data["Output"].first_valid_index()
+        user_message = data_editor_data["Input"][first_input_key].strip()
+        expected_output = data_editor_data["Output"][first_output_key].strip()
+
+        input_acceptance_criteria = initial_acceptance_criteria.strip() if 'initial_acceptance_criteria' in st.session_state else ""
+        input_system_message = initial_system_message.strip() if 'initial_system_message' in st.session_state else ""
+
+        if active_model_tab == "Simple":
+            system_message, output, analysis, acceptance_criteria, chat_log = process_message_with_single_llm(
+                user_message,
+                expected_output,
+                input_acceptance_criteria,
+                input_system_message,
+                recursion_limit,
+                max_output_age,
+                simple_model_name,
+                prompt_template_group,
+                aggressive_exploration,
+            )
+        elif active_model_tab == "Advanced":
+            system_message, output, analysis, acceptance_criteria, chat_log = process_message_with_2_llms(
+                user_message,
+                expected_output,
+                input_acceptance_criteria,
+                input_system_message,
+                recursion_limit,
+                max_output_age,
+                advanced_optimizer_model_name_input,
+                advanced_executor_model_name_input,
+                prompt_template_group,
+                aggressive_exploration,
+            )
+        else:  # Expert
+            system_message, output, analysis, acceptance_criteria, chat_log = process_message_with_expert_llms(
+                user_message,
+                expected_output,
+                input_acceptance_criteria,
+                input_system_message,
+                recursion_limit,
+                max_output_age,
+                expert_prompt_initial_developer_model_name,
+                expert_prompt_initial_developer_temperature_input,
+                expert_prompt_acceptance_criteria_model_name,
+                expert_prompt_acceptance_criteria_temperature_input,
+                expert_prompt_developer_model_name,
+                expert_prompt_developer_temperature_input,
+                expert_prompt_executor_model_name,
+                expert_prompt_executor_temperature_input,
+                expert_prompt_output_history_analyzer_model_name,
+                expert_prompt_output_history_analyzer_temperature_input,
+                expert_prompt_analyzer_model_name,
+                expert_prompt_analyzer_temperature_input,
+                expert_prompt_suggester_model_name,
+                expert_prompt_suggester_temperature_input,
+                prompt_template_group,
+                aggressive_exploration,
+            )
+        
+        st.session_state.system_message_output = system_message
+        st.session_state.output = output
+        st.session_state.analysis = analysis
+        st.session_state.acceptance_criteria_output = acceptance_criteria
+        st.session_state.chat_log = chat_log
+
+    except Exception as e:
+        st.error(f"Error: {e}")
+
 
 if active_model_tab == "Simple":
     simple_model_name = simple_model_name_input
@@ -543,13 +616,14 @@ max_output_age = max_output_age_input
 aggressive_exploration = aggressive_exploration_input
 
 data_editor_data = st.data_editor(
-    st.session_state.meta_prompt_input_data,
+    st.session_state.shared_input_data,
+    # key="meta_prompt_input_data",
     num_rows="dynamic",
     column_config={
         "Input": st.column_config.TextColumn("Input", width="large"),
         "Output": st.column_config.TextColumn("Output", width="large"),
     },
-    hide_index=True,
+    hide_index=False,
     use_container_width=True,
 )
 
@@ -557,91 +631,51 @@ col1, col2 = st.columns(2)
 
 with col1:
     with st.expander("Advanced Inputs"):
-        initial_system_message = st.text_area("Initial System Message", st.session_state.initial_system_message).strip()
-        acceptance_criteria = st.text_area("Acceptance Criteria", st.session_state.initial_acceptance_criteria).strip()
-    
+
+        initial_system_message = st.text_area(
+            "Initial System Message",
+            # "Default System Message",
+            # st.session_state.initial_system_message,
+            key="initial_system_message"
+        )
+
+        col1_1, col1_2 = st.columns(2)
+        with col1_1:
+            pull_sample_description_button = st.button("Pull Sample Description", key="pull_sample_description",
+                                                       on_click=pull_sample_description)
+        with col1_2:
+            st.button("Pull Output", key="copy_system_message",
+                      on_click=copy_system_message)
+        initial_acceptance_criteria = st.text_area(
+            "Acceptance Criteria",
+            # "Default Acceptance Criteria",
+            # st.session_state.initial_acceptance_criteria,
+            key="initial_acceptance_criteria"
+        )
+        st.button("Pull Output", key="copy_acceptance_criteria",
+                  on_click=copy_acceptance_criteria)
+
     col1_1, col1_2, col1_3 = st.columns(3)
     with col1_1:
-        generate_button_clicked = st.button("Generate", type="primary")
+        generate_button_clicked = st.button("Generate", key="generate_button",
+                                            on_click=generate_callback,
+                                            type="primary")
     with col1_2:
-        sync_button_clicked = st.button("Sync", on_click=sync_input_data)
+        sync_button_clicked = st.button("Sync Data", on_click=sync_input_data)
     with col1_3:
         clear_button_clicked = st.button("Clear", on_click=clear_session_state)
 
 with col2:
-    if generate_button_clicked:
-        try:
-            user_message = data_editor_data["Input"][0].strip()
-            expected_output = data_editor_data["Output"][0].strip()
-
-            if active_model_tab == "Simple":
-                system_message, output, analysis, acceptance_criteria, chat_log = process_message_with_single_llm(
-                    user_message,
-                    expected_output,
-                    acceptance_criteria,
-                    initial_system_message,
-                    recursion_limit,
-                    max_output_age,
-                    simple_model_name,
-                    prompt_template_group,
-                    aggressive_exploration,
-                )
-            elif active_model_tab == "Advanced":
-                system_message, output, analysis, acceptance_criteria, chat_log = process_message_with_2_llms(
-                    user_message,
-                    expected_output,
-                    acceptance_criteria,
-                    initial_system_message,
-                    recursion_limit,
-                    max_output_age,
-                    advanced_optimizer_model_name_input,
-                    advanced_executor_model_name_input,
-                    prompt_template_group,
-                    aggressive_exploration,
-                )
-            else:  # Expert
-                system_message, output, analysis, acceptance_criteria, chat_log = process_message_with_expert_llms(
-                    user_message,
-                    expected_output,
-                    acceptance_criteria,
-                    initial_system_message,
-                    recursion_limit,
-                    max_output_age,
-                    expert_prompt_initial_developer_model_name,
-                    expert_prompt_initial_developer_temperature_input,
-                    expert_prompt_acceptance_criteria_model_name,
-                    expert_prompt_acceptance_criteria_temperature_input,
-                    expert_prompt_developer_model_name,
-                    expert_prompt_developer_temperature_input,
-                    expert_prompt_executor_model_name,
-                    expert_prompt_executor_temperature_input,
-                    expert_prompt_output_history_analyzer_model_name,
-                    expert_prompt_output_history_analyzer_temperature_input,
-                    expert_prompt_analyzer_model_name,
-                    expert_prompt_analyzer_temperature_input,
-                    expert_prompt_suggester_model_name,
-                    expert_prompt_suggester_temperature_input,
-                    prompt_template_group,
-                    aggressive_exploration,
-                )
-            
-            st.session_state.system_message_output = system_message
-            st.session_state.output = output
-            st.session_state.analysis = analysis
-            st.session_state.acceptance_criteria_output = acceptance_criteria
-            st.session_state.chat_log = chat_log
-
-        except Exception as e:
-            st.error(f"Error: {e}")
-            
-    st.text_area("System Message",
-                    key="system_message_output", height=100)
-    st.button("Copy System Message", key="copy_system_message",
-                on_click=copy_system_message)
+    system_message_output = st.text_area("System Message",
+                                        # st.session_state.system_message_output,
+                 key="system_message_output",
+                 height=100)
+
     acceptance_criteria_output = st.text_area(
-        "Acceptance Criteria", key="acceptance_criteria_output", height=100)
-    st.button("Copy Acceptance Criteria", key="copy_acceptance_criteria",
-                on_click=copy_acceptance_criteria)
+        "Acceptance Criteria",
+        # st.session_state.acceptance_criteria_output,
+        key="acceptance_criteria_output",
+        height=100)
     st.text_area("Output", st.session_state.output, height=100)
     st.text_area("Analysis", st.session_state.analysis, height=100)
 

app/streamlit_sample_generator.py

@@ -144,8 +144,8 @@ def example_selected():
 
 
 # Session State
-if 'sample_generator_input_data' not in st.session_state:
-    st.session_state.sample_generator_input_data = pd.DataFrame(columns=["Input", "Output"])
+if 'shared_input_data' not in st.session_state:
+    st.session_state.shared_input_data = pd.DataFrame(columns=["Input", "Output"])
 
 if 'description_output_text' not in st.session_state:
     st.session_state.description_output_text = ''
@@ -245,7 +245,7 @@ def import_input_data_from_json():
             data = st.session_state.input_file.getvalue()
             data = json.loads(data)
             data = [{k.capitalize(): v for k, v in d.items()} for d in data]
-            st.session_state.sample_generator_input_data = pd.DataFrame(data)
+            st.session_state.shared_input_data = pd.DataFrame(data)
     except Exception as e:
         st.warning(f"Failed to import JSON: {str(e)}")
 
@@ -278,11 +278,11 @@ def add_new_suggestion():
         st.session_state.new_suggestion = ""  # Clear the input field
 
 def sync_input_data():
-    st.session_state.meta_prompt_input_data = input_data.copy()
-    st.session_state.sample_generator_input_data = input_data.copy()
+    # st.session_state.meta_prompt_input_data = input_data.copy()
+    st.session_state.shared_input_data = input_data.copy()
 
 def clear_session_state():
-    st.session_state.sample_generator_input_data = pd.DataFrame(columns=["Input", "Output"])
+    st.session_state.shared_input_data = pd.DataFrame(columns=["Input", "Output"])
     st.session_state.description_output_text = ''
     st.session_state.suggestions = []
     st.session_state.input_analysis_output_text = ''
@@ -298,13 +298,15 @@ st.markdown("Enter input-output pairs in the table below to generate a task desc
 
 # Input column
 input_data = st.data_editor(
-    st.session_state.sample_generator_input_data,
+    st.session_state.shared_input_data,
+    # key="sample_generator_input_data",
     num_rows="dynamic",
     use_container_width=True,
     column_config={
         "Input": st.column_config.TextColumn("Input", width="large"),
         "Output": st.column_config.TextColumn("Output", width="large"),
     },
+    hide_index=False
 )
 
 with st.expander("Model Settings"):
@@ -336,7 +338,7 @@ with col1:
         "Generate", type="primary", on_click=generate_examples_dataframe)
 with col2:
     sync_button = st.button(
-        "Sync", on_click=sync_input_data)
+        "Sync Data", on_click=sync_input_data)
 with col3:
     clear_button = st.button(
         "Clear", on_click=clear_session_state)
@@ -370,7 +372,7 @@ with st.expander("Description and Analysis"):
 
     examples_directly_output = st.dataframe(st.session_state.examples_directly_dataframe, use_container_width=True,
                                             selection_mode="multi-row", key="selected_example_directly_id",
-                                            on_select=example_directly_selected)
+                                            on_select=example_directly_selected, hide_index=False)
     input_analysis_output = st.text_area(
         "Input Analysis", value=st.session_state.input_analysis_output_text, height=100)
     generate_briefs_button = st.button(
@@ -381,21 +383,21 @@ with st.expander("Description and Analysis"):
         "Generate Examples from Briefs", on_click=update_examples_from_briefs_dataframe)
     examples_from_briefs_output = st.dataframe(st.session_state.examples_from_briefs_dataframe, use_container_width=True,
                                                selection_mode="multi-row", key="selected_example_from_briefs_id",
-                                               on_select=example_from_briefs_selected)
+                                               on_select=example_from_briefs_selected, hide_index=False)
 
 examples_output = st.dataframe(st.session_state.examples_dataframe, use_container_width=True,
-                               selection_mode="multi-row", key="selected_example_id", on_select=example_selected)
+                               selection_mode="multi-row", key="selected_example_id", on_select=example_selected, hide_index=True)
 
 def append_selected_to_input_data():
     if st.session_state.selected_example is not None:
-        st.session_state.sample_generator_input_data = pd.concat(
-            [st.session_state.sample_generator_input_data, st.session_state.selected_example], ignore_index=True)
+        st.session_state.shared_input_data = pd.concat(
+            [input_data, st.session_state.selected_example], ignore_index=True)
         st.session_state.selected_example = None
 
 def show_sidebar():
     if st.session_state.selected_example is not None:
         with st.sidebar:
-            st.dataframe(st.session_state.selected_example)  # Display DataFrame in sidebar
+            st.dataframe(st.session_state.selected_example, hide_index=False)  # Display DataFrame in sidebar
             st.button("Append to Input Data", on_click=append_selected_to_input_data)
 
 show_sidebar()

config.yml

@@ -82,6 +82,7 @@ recursion_limit_max: 25
 max_output_age: 2
 allow_flagging: false
 # verbose: false
+verbose: true
 
 prompt_templates:
 

guidelines/streamlit.md

@@ -1,723 +1,224 @@
-# Streamlit Guideline
+# Streamlit Project Guideline
 
 ## 1. Framework Overview
 
-### Introduction to Streamlit
-Streamlit is an open-source app framework specifically designed for Machine Learning and Data Science teams. It allows developers to create web apps for their data projects quickly and efficiently using Python scripting. Streamlit's key features include its simplicity, ease of use, and the ability to build and deploy apps rapidly.
-
-### Key Features
-- **Simplicity**: Streamlit's API is designed to be intuitive and easy to use, making it accessible for both beginners and experienced developers.
-- **Rapid Development**: With Streamlit, you can go from idea to app in minutes, thanks to its reactive programming model.
-- **Python-Centric**: Streamlit leverages Python for all the coding, making it a favorite among data scientists and ML engineers.
-- **Rich Widgets**: Streamlit provides a variety of widgets like sliders, buttons, and text inputs, which enhance user interaction with the app.
-
-### Advantages
-- **No Frontend Experience Required**: Developers can focus on Python scripting without needing to learn HTML, CSS, or JavaScript.
-- **Automatic UI Updates**: Streamlit automatically updates the web app when the script is modified, facilitating rapid prototyping.
-- **Seamless Integration**: It integrates well with other Python libraries and tools commonly used in data science and ML.
-
-## 2. Installation and Setup
-
-### Step-by-Step Installation
-1. **Install Streamlit**: Open your terminal and run the following command to install Streamlit using pip:
-   ```bash
-   pip install streamlit
-   ```
-2. **Verify Installation**: To ensure Streamlit is installed correctly, run:
-   ```bash
-   streamlit hello
-   ```
-   This command will open a sample app in your default web browser.
-
-### Setting Up a New Project
-1. **Create a New Directory**:
-   ```bash
-   mkdir my_streamlit_app
-   cd my_streamlit_app
-   ```
-2. **Create a Python Script**: Create a new Python file, e.g., `app.py`.
-3. **Write Your First App**: Open `app.py` in your favorite text editor and add the following lines:
-   ```python
-   import streamlit as st
-
-   st.title("My First Streamlit App")
-   st.write("Hello, world!")
-   ```
-4. **Run Your App**: In the terminal, run:
-   ```bash
-   streamlit run app.py
-   ```
-   This command will start a local web server and open your app in the browser.
-
-### Prerequisites and Dependencies
-- **Python**: Ensure Python 3.6 or later is installed on your system.
-- **Pip**: Pip should be installed to manage Python packages.
-
-## 3. Core Concepts
-
-### Fundamental Concepts and Principles
-- **Reactive Programming**: Streamlit follows a reactive programming model where changes in the script automatically update the app.
-- **Widgets**: Streamlit provides various widgets (e.g., sliders, buttons, text inputs) to interact with the app.
-- **Layouts and Containers**: Streamlit allows you to organize your app's layout using columns, containers, and expanders.
-
-### Architecture and Design Patterns
-- **Single-Page App**: Streamlit apps are typically single-page applications where the entire app runs within a single HTML page.
-- **State Management**: Streamlit manages the state of the app automatically, but you can use session state for more complex state management.
-
-## 4. Component Structure
-
-### Creating and Structuring Components
-
-Streamlit provides a variety of components to build interactive web applications. These components range from simple text displays to complex widgets that allow user input. Understanding how to structure and use these components is crucial for building effective Streamlit apps.
-
-Here is the list of components with brief descriptions, examples, and links to the reference page:
-
-### Basic Components
-
-* `st.title()`: Display a title.
-	+ Example: `st.title("My Streamlit App")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/text/st.title)
-* `st.header()`: Display a header.
-	+ Example: `st.header("Welcome to My App")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/text/st.header)
-* `st.subheader()`: Display a subheader.
-	+ Example: `st.subheader("This is a subheader")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/text/st.subheader)
-* `st.text()`: Display fixed-width text.
-	+ Example: `st.text("Some fixed-width text")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/text/st.text)
-* `st.markdown()`: Render markdown text.
-	+ Example: `st.markdown("**Bold** and *italic* text")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/text/st.markdown)
-* `st.latex()`: Display mathematical expressions formatted as LaTeX.
-	+ Example: `st.latex(r"\alpha + \beta = \gamma")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/text/st.latex)
-* `st.write()`: Write a generic piece of text or data.
-	+ Example: `st.write("Here's a dataframe:", df)`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/write-magic/st.write)
-* `st.dataframe()`: Display a dataframe.
-	+ Example: `st.dataframe(df)`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/data/st.dataframe)
-* `st.table()`: Display a static table.
-	+ Example: `st.table(df)`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/data/st.table)
-* `st.json()`: Display JSON data.
-	+ Example: `st.json(df.to_json())`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/data/st.json)
-* `st.button()`: Create a button.
-	+ Example: `if st.button("Click me"): st.write("Button clicked!")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/widgets/st.button)
-* `st.checkbox()`: Create a checkbox.
-	+ Example: `agree = st.checkbox("I agree")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/widgets/st.checkbox)
-* `st.radio()`: Create a radio button group.
-	+ Example: `option = st.radio("Choose an option", ["Option 1", "Option 2"])`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/widgets/st.radio)
-* `st.selectbox()`: Create a select box.
-	+ Example: `choice = st.selectbox("Select an option", ["A", "B", "C"])`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/widgets/st.selectbox)
-* `st.multiselect()`: Create a multiselect box.
-	+ Example: `multi_choices = st.multiselect("Choose multiple options", ["X", "Y", "Z"])`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/widgets/st.multiselect)
-* `st.slider()`: Create a slider.
-	+ Example: `value = st.slider("Select a value", 0, 100, 50)`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/widgets/st.slider)
-* `st.text_input()`: Create a text input box.
-	+ Example: `text = st.text_input("Enter some text")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/widgets/st.text_input)
-* `st.number_input()`: Create a number input box.
-	+ Example: `number = st.number_input("Enter a number")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/widgets/st.number_input)
-* `st.date_input()`: Create a date input box.
-	+ Example: `date = st.date_input("Select a date")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/widgets/st.date_input)
-* `st.time_input()`: Create a time input box.
-	+ Example: `time = st.time_input("Select a time")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/widgets/st.time_input)
-* `st.file_uploader()`: Allow file uploads.
-	+ Example: `file = st.file_uploader("Upload a file")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/widgets/st.file_uploader)
-
-### Layout Components
-
-* `st.sidebar()`: Add content to the sidebar.
-	+ Example: `st.sidebar.title("Sidebar Title")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/layout/st.sidebar)
-* `st.columns()`: Create columns for layout.
-	+ Example: `col1, col2 = st.columns(2)`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/layout/st.columns)
-* `st.expander()`: Create an expandable container.
-	+ Example: `with st.expander("Click to expand"): st.write("Expanded content")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/layout/st.expander)
-* `st.container()`: Insert a multi-element container.
-	+ Example: `c = st.container()`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/layout/st.container)
-* `st.empty()`: Insert a single-element container.
-	+ Example: `c = st.empty()`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/layout/st.empty)
-* `st.tabs()`: Insert containers separated into tabs.
-	+ Example: `tab1, tab2 = st.tabs(["Tab 1", "Tab 2"])`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/layout/st.tabs)
-
-### Status Components
-
-* `st.progress()`: Display a progress bar.
-	+ Example: `with st.progress(100): do_something()`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/status/st.progress)
-* `st.spinner()`: Display a spinning wheel.
-	+ Example: `with st.spinner("Wait for it..."): do_something()`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/status/st.spinner)
-* `st.success()`: Display a success message.
-	+ Example: `st.success("Done!")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/status/st.success)
-* `st.error()`: Display an error message.
-	+ Example: `st.error("Error message")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/status/st.error)
-* `st.warning()`: Display a warning message.
-	+ Example: `st.warning("Warning message")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/status/st.warning)
-* `st.info()`: Display an info message.
-	+ Example: `st.info("Info message")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/status/st.info)
-* `st.exception()`: Display an exception message.
-	+ Example: `st.exception("Exception message")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/status/st.exception)
-* `st.stop()`: Stop the app.
-	+ Example: `st.stop()`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/status/st.stop)
-
-### Navigation Components
-
-* `st.page_link()`: Display a link to another page in a multipage app.
-	+ Example: `st.page_link("app.py", label="Home", icon="🏠")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/widgets/st.page_link)
-* `st.navigation()`: Configure the available pages in a multipage app.
-	+ Example: `st.navigation({"Your account": [log_out, settings]})`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/navigation/st.navigation)
-* `st.page()`: Define a page in a multipage app.
-	+ Example: `home = st.Page("home.py", title="Home", icon="🏠")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/navigation/st.page)
-* `st.switch_page()`: Programmatically navigate to a specified page.
-	+ Example: `st.switch_page("pages/my_page.py")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/navigation/st.switch_page)
-
-### Execution Flow Components
-
-* `st.form()`: Create a form that batches elements together with a “Submit” button.
-	+ Example: `with st.form(key="my_form"): name = st.text_input("Name")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/execution-flow/st.form)
-* `st.form_submit_button()`: Create a form submit button.
-	+ Example: `st.form_submit_button("Sign up")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/execution-flow/st.form_submit_button)
-* `st.dialog()`: Insert a modal dialog that can rerun independently from the rest of the script.
-	+ Example: `@st.dialog("Sign up") def email_form(): name = st.text_input("Name")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/execution-flow/st.dialog)
-* `st.fragment()`: Define a fragment to rerun independently from the rest of the script.
-	+ Example: `@st.fragment(run_every="10s") def fragment(): df = get_data()`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/execution-flow/st.fragment)
-* `st.rerun()`: Rerun the script immediately.
-	+ Example: `st.rerun()`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/execution-flow/st.rerun)
-* `st.stop()`: Stop the app.
-	+ Example: `st.stop()`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/execution-flow/st.stop)
-
-### Caching and State Components
-
-* `st.cache_data()`: Function decorator to cache functions that return data.
-	+ Example: `@st.cache_data def long_function(param1, param2): return data`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/caching-and-state/st.cache_data)
-* `st.cache_resource()`: Function decorator to cache functions that return global resources.
-	+ Example: `@st.cache_resource def init_model(): return pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/caching-and-state/st.cache_resource)
-* `st.session_state()`: Session state is a way to share variables between reruns, for each user session.
-	+ Example: `st.session_state["key"] = value`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/caching-and-state/st.session_state)
-* `st.query_params()`: Get, set, or clear the query parameters that are shown in the browser's URL bar.
-	+ Example: `st.query_params["key"] = value`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/caching-and-state/st.query_params)
-
-### Utilities Components
-
-* `st.context()`: st.context provides a read-only interface to access cookies and headers.
-	+ Example: `st.context.cookies`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/utilities/st.context)
-* `st.help()`: Display object’s doc string, nicely formatted.
-	+ Example: `st.help(st.write)`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/utilities/st.help)
-* `st.html()`: Renders HTML strings to your app.
-	+ Example: `st.html("<p>Foo bar.</p>")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/utilities/st.html)
-* `st.experimental_user()`: st.experimental_user returns information about the logged-in user of private apps on Streamlit Community Cloud.
-	+ Example: `if st.experimental_user.email == "[email protected]": st.write("Welcome back,", st.experimental_user.email)`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/utilities/st.experimental_user)
-
-### Testing Components
-
-* `st.testing.v1.AppTest`: Simulates a running Streamlit app for testing.
-	+ Example: `at = AppTest.from_file("streamlit_app.py")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/st.testing.v1.apptest)
-* `st.testing.v1.ElementTree`: A representation of container elements.
-	+ Example: `at.sidebar`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreeblock)
-* `st.testing.v1.Block`: A representation of container elements.
-	+ Example: `at.sidebar`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreeblock)
-* `st.testing.v1.Element`: The base class for representation of all elements.
-	+ Example: `at.title`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreeelement)
-* `st.testing.v1.Button`: A representation of st.button and st.form_submit_button.
-	+ Example: `at.button`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreebutton)
-* `st.testing.v1.ChatInput`: A representation of st.chat_input.
-	+ Example: `at.chat_input`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreechatinput)
-* `st.testing.v1.Checkbox`: A representation of st.checkbox.
-	+ Example: `at.checkbox`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreecheckbox)
-* `st.testing.v1.ColorPicker`: A representation of st.color_picker.
-	+ Example: `at.color_picker`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreecolorpicker)
-* `st.testing.v1.DateInput`: A representation of st.date_input.
-	+ Example: `at.date_input`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreedateinput)
-* `st.testing.v1.Multiselect`: A representation of st.multiselect.
-	+ Example: `at.multiselect`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreemultiselect)
-* `st.testing.v1.NumberInput`: A representation of st.number_input.
-	+ Example: `at.number_input`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreenumberinput)
-* `st.testing.v1.Radio`: A representation of st.radio.
-	+ Example: `at.radio`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreeradio)
-* `st.testing.v1.SelectSlider`: A representation of st.select_slider.
-	+ Example: `at.select_slider`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreeselectslider)
-* `st.testing.v1.Selectbox`: A representation of st.selectbox.
-	+ Example: `at.selectbox`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreeselectbox)
-* `st.testing.v1.Slider`: A representation of st.slider.
-	+ Example: `at.slider`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreeslider)
-* `st.testing.v1.TextArea`: A representation of st.text_area.
-	+ Example: `at.text_area`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreetextarea)
-* `st.testing.v1.TextInput`: A representation of st.text_input.
-	+ Example: `at.text_input`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreetextinput)
-* `st.testing.v1.TimeInput`: A representation of st.time_input.
-	+ Example: `at.time_input`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreetimeinput)
-* `st.testing.v1.Toggle`: A representation of st.toggle.
-	+ Example: `at.toggle`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/app-testing/testing-element-classes#sttestingv1element%5Ftreetoggle)
-
-### Custom Components
-
-* `st.components.v1.declare_component()`: Create and register a custom component.
-	+ Example: `declare_component("custom_slider", "/frontend")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/custom-components/st.components.v1.declare_component)
-* `st.components.v1.html()`: Display an HTML string in an iframe.
-	+ Example: `html("<p>Foo bar.</p>")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/custom-components/st.components.v1.html)
-* `st.components.v1.iframe()`: Load a remote URL in an iframe.
-	+ Example: `iframe("docs.streamlit.io")`
-	+ [Reference](https://docs.streamlit.io/develop/api-reference/custom-components/st.components.v1.iframe)
-    
-### Examples of Different Types of Components
-
-#### Functional Components
-Functional components are straightforward and used for displaying static content.
+Streamlit is an open-source Python library that makes it easy to create and share custom web apps for machine learning and data science. It allows developers to build web applications quickly by writing pure Python scripts. Streamlit's key features include its simplicity, ease of use, and the ability to seamlessly integrate with other data science tools and libraries.
 
-```python
-st.title("Welcome to My App")
-st.header("Main Features")
-st.subheader("Feature 1")
-st.text("This is a description of feature 1.")
-st.markdown("**Feature 2** is also important.")
-```
+## 2. Component Structure
 
-#### Stateful Components
-Stateful components involve user interaction and can change based on user input.
+### Component Types
 
-```python
-if 'count' not in st.session_state:
-    st.session_state.count = 0
+In the provided project, the components are primarily function-based, focusing on data processing, generation, and UI interactions. The main types of components identified are:
 
-def increment_counter():
-    st.session_state.count += 1
-
-st.button('Increment', on_click=increment_counter)
-st.write('Count:', st.session_state.count)
-```
+- **Data Processing Functions**: Functions like `process_json`, `generate_description_only`, and `analyze_input` handle data processing tasks.
+- **UI Interaction Functions**: Functions like `example_directly_selected`, `example_from_briefs_selected`, and `example_selected` manage user interactions within the Streamlit UI.
+- **Session State Management**: Functions and blocks that handle session state, such as initializing session state variables and updating them based on user actions.
 
-### Lifecycle Methods or Hooks
+### Example Components
 
-Streamlit does not have traditional lifecycle methods like React, but you can use callbacks and session state to manage component behavior.
+#### Data Processing Function
 
 ```python
-if 'count' not in st.session_state:
-    st.session_state.count = 0
-
-def increment_counter():
-    st.session_state.count += 1
-
-st.button('Increment', on_click=increment_counter)
-st.write('Count:', st.session_state.count)
+def process_json(input_json, model_name, generating_batch_size, temperature):
+    try:
+        model = ChatOpenAI(
+            model=model_name, temperature=temperature, max_retries=3)
+        generator = TaskDescriptionGenerator(model)
+        result = generator.process(input_json, generating_batch_size)
+        # Processing logic...
+        return description, suggestions, examples_directly, input_analysis, new_example_briefs, examples_from_briefs, examples
+    except Exception as e:
+        st.warning(f"An error occurred: {str(e)}. Returning default values.")
+        return "", [], [], "", [], [], []
 ```
 
-## 5. UI Operations and Callbacks
-
-### Handling User Interactions and Events
-
-User interactions are a core part of any interactive web application. Streamlit provides various widgets to capture user input and trigger actions based on these inputs.
-
-#### Button Clicks
-Buttons are used to trigger actions. You can use the `on_click` parameter to define a callback function.
+#### UI Interaction Function
 
 ```python
-if st.button('Click Me'):
-    st.write('Button Clicked!')
+def example_directly_selected():
+    if 'selected_example_directly_id' in st.session_state:
+        try:
+            selected_example_ids = st.session_state.selected_example_directly_id[
+                'selection']['rows']
+            # Interaction logic...
+        except Exception as e:
+            st.session_state.selected_example = None
 ```
 
-#### Form Submissions
-Forms are used to group related inputs and can be submitted together.
+#### Session State Management
 
 ```python
-with st.form(key='my_form'):
-    text_input = st.text_input(label='Enter some text')
-    submit_button = st.form_submit_button(label='Submit')
+if 'input_data' not in st.session_state:
+    st.session_state.input_data = pd.DataFrame(columns=["Input", "Output"])
 
-if submit_button:
-    st.write(f'You entered: {text_input}')
+if 'description_output_text' not in st.session_state:
+    st.session_state.description_output_text = ''
 ```
 
-#### Checkboxes
-Checkboxes are used to capture boolean inputs.
+## 3. UI Operations and Callbacks
 
-```python
-agree = st.checkbox("I agree")
-if agree:
-    st.write("Great! You agreed.")
-```
+### Common UI Operations
 
-#### Radio Buttons
-Radio buttons allow users to select one option from a set.
+- **Button Clicks**: Handling button clicks to trigger data processing or state updates.
+- **Data Editing**: Allowing users to edit data tables directly within the UI.
+- **File Uploads and Downloads**: Managing file uploads for importing data and file downloads for exporting data.
 
-```python
-option = st.radio("Choose an option", ["Option 1", "Option 2"])
-st.write("You selected:", option)
-```
+### Example UI Operations
 
-#### Select Boxes
-Select boxes allow users to select one option from a dropdown.
+#### Button Click Handling
 
 ```python
-choice = st.selectbox("Select an option", ["A", "B", "C"])
-st.write("You selected:", choice)
+submit_button = st.button(
+    "Generate", type="primary", on_click=generate_examples_dataframe)
 ```
 
-#### Multiselect Boxes
-Multiselect boxes allow users to select multiple options.
+#### Data Editing
 
 ```python
-multi_choices = st.multiselect("Choose multiple options", ["X", "Y", "Z"])
-st.write("You selected:", multi_choices)
+input_data = st.data_editor(
+    st.session_state.input_data,
+    num_rows="dynamic",
+    use_container_width=True,
+    column_config={
+        "Input": st.column_config.TextColumn("Input", width="large"),
+        "Output": st.column_config.TextColumn("Output", width="large"),
+    },
+)
 ```
 
-#### Sliders
-Sliders allow users to select a value from a range.
+#### File Upload and Download
 
 ```python
-value = st.slider("Select a value", 0, 100, 50)
-st.write("You selected:", value)
+input_file = st.file_uploader(
+    label="Import Input Data from JSON",
+    type="json",
+    key="input_file",
+    on_change=import_input_data_from_json
+)
+
+export_button = st.button(
+    "Export Input Data to JSON", on_click=export_input_data_to_json
+)
 ```
 
-#### Text Inputs
-Text inputs allow users to enter text.
+## 4. State Management
+
+### State Management Approach
+
+Streamlit uses a session state to manage the state of the application across reruns. The session state allows developers to persist variables across reruns, enabling more complex interactions and workflows.
+
+### Example State Management
+
+#### Initializing Session State
 
 ```python
-text = st.text_input("Enter some text")
-st.write("You entered:", text)
+if 'input_data' not in st.session_state:
+    st.session_state.input_data = pd.DataFrame(columns=["Input", "Output"])
 ```
 
-#### Number Inputs
-Number inputs allow users to enter numeric values.
+#### Updating Session State
 
 ```python
-number = st.number_input("Enter a number")
-st.write("You entered:", number)
+def update_description_output_text():
+    input_json = package_input_data()
+    result = generate_description_only(input_json, model_name, temperature)
+    st.session_state.description_output_text = result[0]
+    st.session_state.suggestions = result[1]
 ```
 
-#### Date and Time Inputs
-Date and time inputs allow users to select dates and times.
+## 5. Routing
 
-```python
-date = st.date_input("Select a date")
-st.write("You selected:", date)
+Streamlit does not support traditional client-side routing like other frontend frameworks. Instead, it focuses on creating single-page applications where the URL does not change. Navigation within a Streamlit app is typically handled through the sidebar or buttons that trigger reruns of the script.
 
-time = st.time_input("Select a time")
-st.write("You selected:", time)
-```
+## 6. Data Fetching
+
+### Data Fetching Methods
+
+Data fetching in Streamlit is often done through direct API calls within the script. The fetched data is then processed and displayed within the app.
 
-#### File Uploaders
-File uploaders allow users to upload files.
+### Example Data Fetching
 
 ```python
-file = st.file_uploader("Upload a file")
-if file is not None:
-    st.write("File uploaded:", file.name)
+def process_json(input_json, model_name, generating_batch_size, temperature):
+    try:
+        model = ChatOpenAI(
+            model=model_name, temperature=temperature, max_retries=3)
+        generator = TaskDescriptionGenerator(model)
+        result = generator.process(input_json, generating_batch_size)
+        # Data processing logic...
+        return description, suggestions, examples_directly, input_analysis, new_example_briefs, examples_from_briefs, examples
+    except Exception as e:
+        st.warning(f"An error occurred: {str(e)}. Returning default values.")
+        return "", [], [], "", [], [], []
 ```
 
-### Implementing and Using Callbacks
+## 7. Styling
 
-Callbacks are functions that are called when a specific event occurs, such as a button click or form submission. Streamlit allows you to define callbacks using the `on_click` and `on_change` parameters.
+### Styling Approaches
 
-#### Callbacks with Session State
-Callbacks can be used to update the session state, allowing you to manage state across reruns of the app.
+Streamlit provides basic styling options through its API, such as `st.markdown` for custom HTML and CSS, and `st.sidebar` for organizing content. For more advanced styling, custom CSS can be injected using `st.markdown` with HTML tags.
 
-```python
-if 'count' not in st.session_state:
-    st.session_state.count = 0
-
-def increment_counter():
-    st.session_state.count += 1
+### Example Styling
 
-st.button('Increment', on_click=increment_counter)
-st.write('Count:', st.session_state.count)
+```python
+st.title("LLM Task Example Generator")
+st.markdown("Enter input-output pairs in the table below to generate a task description, analysis, and additional examples.")
 ```
 
-#### Callbacks with Forms
-Callbacks can also be used with forms to handle form submissions.
+## 8. Performance Optimization
 
-```python
-with st.form(key='my_form'):
-    text_input = st.text_input(label='Enter some text')
-    submit_button = st.form_submit_button(label='Submit')
+### Optimization Techniques
 
-if submit_button:
-    st.write(f'You entered: {text_input}')
-```
+- **Code Splitting**: Not applicable in Streamlit as it is a single-page application framework.
+- **Lazy Loading**: Not directly supported; however, conditional rendering can be used to load components only when needed.
+- **Memoization**: Use Streamlit's `@st.cache` decorator to cache expensive computations.
 
-#### Callbacks with Widgets
-Callbacks can be used with various widgets to handle user interactions.
+### Example Optimization
 
 ```python
-def on_change():
-    st.write(f'Value changed to: {st.session_state.slider_value}')
-
-st.slider('Select a value', 0, 100, key='slider_value', on_change=on_change)
+@st.cache
+def process_json(input_json, model_name, generating_batch_size, temperature):
+    # Expensive computation...
+    return result
 ```
 
-By leveraging these components and callbacks, you can create interactive and dynamic Streamlit applications that respond to user inputs and actions.
+## 9. Testing
 
-### Multipage apps
+### Testing Methodologies
 
-Streamlit offers two primary methods for creating multipage apps: using the `pages/` directory for a quick setup or leveraging `st.Page` and `st.navigation` for more customization.
+Streamlit applications can be tested using traditional Python testing frameworks like `unittest` and `pytest`. Integration and end-to-end tests can be challenging due to the nature of Streamlit's rerun mechanism.
 
-#### Overview
+### Example Testing
 
-- **Using `pages/` Directory**: Place Python files in a `pages/` directory next to your entrypoint file. Streamlit automatically creates pages based on these files and populates a navigation menu in the sidebar.
-  - **Example**:
-    ```
-    your_working_directory/
-    ├── pages/
-    │   ├── a_page.py
-    │   └── another_page.py
-    └── your_homepage.py
-    ```
-  - **Run**: `streamlit run your_homepage.py`
-
-- **Using `st.Page` and `st.navigation`**: This method offers more flexibility. Define pages using `st.Page` and configure navigation with `st.navigation` in your entrypoint file.
-  - **Example**:
-    ```python
-    import streamlit as st
-    pg = st.navigation([st.Page("page_1.py"), st.Page("page_2.py")])
-    pg.run()
-    ```
-
-#### Page Terminology
-
-- **Page Source**: Python file or callable function.
-- **Page Label**: Identifies the page in the navigation menu.
-- **Page Title**: HTML `<title>` element content.
-- **Page URL Pathname**: Relative path from the root URL.
-- **Page Icons**: Favicon and icon next to the page label.
-
-#### Navigation
-
-- **Default Navigation**: Appears in the sidebar.
-- **Custom Navigation**: Use `st.page_link` to build a custom menu.
-- **Programmatic Navigation**: Use `st.switch_page`.
-
-#### Widget Statefulness
-
-Widgets reset to default values when switching pages. To maintain state:
-
-- **Option 1**: Place widgets in the entrypoint file (only works with `st.Page` and `st.navigation`).
-  - **Example**:
-    ```python
-    import streamlit as st
-    pg = st.navigation([st.Page("page_1.py"), st.Page("page_2.py")])
-    st.sidebar.selectbox("Group", ["A", "B", "C"], key="group")
-    st.sidebar.slider("Size", 1, 5, key="size")
-    pg.run()
-    ```
-
-- **Option 2**: Use a separate key in `st.session_state` to save widget values.
-  - **Example**:
-    ```python
-    import streamlit as st
-    def store_value(key):
-        st.session_state[key] = st.session_state["_" + key]
-    def load_value(key):
-        st.session_state["_" + key] = st.session_state[key]
-    load_value("my_key")
-    st.number_input("Number of filters", key="_my_key", on_change=store_value, args=["my_key"])
-    ```
-
-- **Option 3**: Ensure widget values persist by checking `st.session_state` at the top of each page.
-  - **Example**:
-    ```python
-    if "my_key" in st.session_state:
-        st.session_state.my_key = st.session_state.my_key
-    ```
-
-For more details, refer to the [Streamlit documentation](https://docs.streamlit.io/develop/concepts/multipage-apps).
-
-_forum_
-
-### Still have questions?
-
-Our [forums](https://discuss.streamlit.io/) are full of helpful information and Streamlit experts.
-
-## 6. State Management
-
-### Framework's Approach to State Management
-- **Session State**: Streamlit provides a session state API to manage state across reruns of the app.
-- **Example**:
-  ```python
-  if 'count' not in st.session_state:
-      st.session_state.count = 0
-
-  def increment_counter():
-      st.session_state.count += 1
-
-  st.button('Increment', on_click=increment_counter)
-  st.write('Count:', st.session_state.count)
-  ```
-
-## 7. Routing
-
-### Routing System
-- Streamlit does not have a traditional routing system like React Router. All navigation is handled within the single-page app.
-
-## 8. Data Fetching
-
-### Fetching and Handling Data from APIs
-- **Example**:
-  ```python
-  import requests
-
-  response = requests.get('https://api.example.com/data')
-  data = response.json()
-  st.write(data)
-  ```
-
-### Error Handling and Loading States
-- **Error Handling**:
-  ```python
-  try:
-      response = requests.get('https://api.example.com/data')
-      response.raise_for_status()
-      data = response.json()
-      st.write(data)
-  except requests.exceptions.HTTPError as err:
-      st.error(f'Error fetching data: {err}')
-  ```
-- **Loading States**:
-  ```python
-  with st.spinner('Loading...'):
-      response = requests.get('https://api.example.com/data')
-      data = response.json()
-      st.write(data)
-  ```
-
-## 9. Styling
-
-### Recommended Approaches for Styling Components
-- **Custom CSS**: Streamlit allows custom CSS for styling.
-- **Example**:
-  ```python
-  st.markdown(
-      """
-      <style>
-      .stButton > button {
-          color: white;
-          background-color: red;
-      }
-      </style>
-      """,
-      unsafe_allow_html=True
-  )
-  ```
-
-### Implementing Responsive Design
-- Streamlit provides built-in responsive design features through its layout components (e.g., columns, containers).
-
-## 10. Performance Optimization
-
-### Guidelines for Optimizing Performance
-- **Caching**: Use Streamlit's caching mechanisms to optimize performance.
-- **Example**:
-  ```python
-  @st.cache
-  def fetch_data():
-      response = requests.get('https://api.example.com/data')
-      return response.json()
-
-  data = fetch_data()
-  st.write(data)
-  ```
-
-## 11. Testing
-
-### Recommended Testing Methodologies
-- **Unit Testing**: Use Python's unittest or pytest frameworks for unit testing.
-- **Integration Testing**: Streamlit apps can be tested using Selenium or other browser automation tools.
-
-## 12. Deployment
-
-### Building and Deploying Applications
-- **Streamlit Sharing**: Streamlit provides a free hosting service called Streamlit Sharing.
-- **Docker**: You can also deploy Streamlit apps using Docker.
-
-## 13. Best Practices and Common Pitfalls
+```python
+import unittest
+from your_streamlit_app import process_json
 
-### Best Practices
-- **Modular Code**: Organize your code into modular functions and files.
-- **Consistent Styling**: Use custom CSS for consistent styling across the app.
-- **Error Handling**: Implement robust error handling for data fetching and user inputs.
+class TestProcessJson(unittest.TestCase):
+    def test_process_json(self):
+        input_json = '{"key": "value"}'
+        result = process_json(input_json, "model_name", 3, 0.5)
+        self.assertEqual(result[0], "expected_description")
 
-### Common Pitfalls
-- **Overusing Session State**: Avoid overusing session state for simple state management.
-- **Performance Issues**: Be mindful of performance issues, especially with large datasets.
+if __name__ == "__main__":
+    unittest.main()
+```
+
+## 10. Best Practices and Common Pitfalls
 
-## 14. Community and Resources
+### Best Practices
 
-### Links to Official Documentation, Community Forums, and Helpful Resources
-- **Official Documentation**: [Streamlit Documentation](https://docs.streamlit.io/)
-- **Community Forum**: [Streamlit Forum](https://discuss.streamlit.io/)
-- **GitHub Repository**: [Streamlit GitHub](https://github.com/streamlit/streamlit)
+- **Modular Code**: Organize code into reusable functions and modules.
+- **Session State Management**: Use session state effectively to manage application state.
+- **Error Handling**: Implement robust error handling to provide a smooth user experience.
+- **Performance Optimization**: Use caching and efficient data handling to optimize performance.
 
-### Popular Tools, Extensions, and Libraries
-- **Streamlit Components**: [Streamlit Components](https://streamlit.io/components)
-- **Awesome Streamlit**: [Awesome Streamlit](https://awesome-streamlit.org/)
+### Common Pitfalls
 
-### Notable Community Projects
-- **Streamlit Gallery**: [Streamlit Gallery](https://streamlit.io/gallery)
-- **Streamlit Cheat Sheet**: [Streamlit Cheat Sheet](https://share.streamlit.io/daniellewisdl/streamlit-cheat-sheet/app.py)
+- **Overuse of Reruns**: Avoid triggering unnecessary reruns, which can degrade performance.
+- **Complex State Management**: Be cautious with complex state management, as it can lead to bugs and unexpected behavior.
+- **Lack of Testing**: Neglecting testing can lead to issues that are hard to debug in a rapidly changing environment.
 
 ## Conclusion
 
-This guideline provides a comprehensive overview of Streamlit, covering its installation, core concepts, component structure, UI operations, state management, data fetching, styling, performance optimization, testing, deployment, best practices, and community resources. By following this guide, developers can effectively utilize Streamlit to create efficient and interactive web applications for data science and machine learning projects.
+This guideline provides a comprehensive overview of using Streamlit within a project, covering component structure, UI operations, state management, data fetching, styling, performance optimization, testing, and best practices. By following these guidelines, developers can create efficient, maintainable, and user-friendly Streamlit applications.