update gui

app.py

@@ -1,27 +1,27 @@
 import gradio as gr
 from chatbot_simulator import ChatbotSimulation
 from task_specific_data_population import DataPopulation
+import re
 import os
 
 openai_api_key = os.getenv("OPENAI_API_KEY")
 
-
 class AppSimulator:
     def __init__(self, openai_api_key):
         self.simulation = None
-        self.conversation = []  # Stores full conversation for logging
-        self.display_conversation = []  # Stores last 2 messages for display
         self.openai_api_key = openai_api_key
 
-    def initialize_simulator(self, task, app_name, sitemap):
-        """Initialize the simulator with retries in case of failure."""
-        success = False
+    def initialize_simulator(self, task, app_name, sitemap, progress=gr.Progress(track_tqdm=True)):
+        """Initialize the simulator with retries and elapsed time tracking."""
         retry_count = 0
         max_retries = 50
 
-        while not success and retry_count < max_retries:
+        while retry_count < max_retries:
             try:
-                # Process data
+                # Display current attempt with progress bar
+                progress.update(f"Initializing... Attempt {retry_count + 1}/{max_retries}")
+
+                # Process data and initialize the simulation
                 data_population = DataPopulation(api_key=self.openai_api_key)
                 sitemap_data, page_details, user_state = data_population.process_data(task, sitemap)
 
@@ -36,93 +36,79 @@ class AppSimulator:
                     agent='human'
                 )
 
-                # Start the conversation and update the logs and display
-                text = self.simulation.start_conversation()
-                self._log_message("assistant", text)
-                self.display_conversation = [('Start Simulator', text)]
-
-                return self.display_conversation
+                # Successful initialization
+                initial_message = self.simulation.start_conversation()
+                progress.update("Initialization Successful")
+                return initial_message  # Return the initial assistant message for chat
             except Exception as e:
                 retry_count += 1
-                print(f"Attempt {retry_count}/{max_retries}: An error occurred: {e}. Retrying...")
+                print(f"Attempt {retry_count}/{max_retries} failed: {e}")
 
-    def chatbot_interaction(self, user_input):
+        # If all retries failed
+        progress.update("Failed to initialize simulator after multiple retries.")
+        return "Initialization failed."  # Error message for chat
+
+    def chat_interaction(self, user_input, history):
         """Handle one round of conversation."""
-        if self.simulation is None:
-            return [("system", "Simulation is not initialized. Please start the simulator.")]
-
-        try:
-            # Get the response from the simulator
-            response = self.simulation.one_conversation_round(user_input)
-
-            # Log both user input and assistant's response
-            self._log_message("user", user_input)
-            self._log_message("assistant", response)
-
-            # Update display conversation (keep last 2 entries)
-            self.display_conversation.extend([(user_input, response)])
-            while len(self.display_conversation) > 2:
-                self.display_conversation.pop(0)
-            print(len(self.display_conversation))
-            return self.display_conversation
-        except Exception as e:
-            return [("system", f"An error occurred: {e}")]
-
-    def _log_message(self, role, content):
-        """Log conversation messages to both memory and file."""
-        self.conversation.append({"role": role, "content": content})
-        self._write_log_to_file(content)
-
-    def _write_log_to_file(self, content):
-        """Append conversation to a log file."""
-        log_location = self.simulation.log_location if self.simulation else "conversation_log.txt"
-        try:
-            with open(log_location, 'a') as f:
-                for message in self.conversation:
-                    f.write(f"{message['role']}: {message['content']}\n\n")
-        except Exception as e:
-            print(f"Error logging conversation: {e}")
-
-
-# JavaScript function to refresh theme to dark mode
-js_func = """
-function refresh() {
-    const url = new URL(window.location);
-    if (url.searchParams.get('__theme') !== 'dark') {
-        url.searchParams.set('__theme', 'dark');
-        window.location.href = url.href;
-    }
-}
-"""
+        return self.simulation.one_conversation_round(user_input)
+
 
+# Initialize the simulator
 simulator_app = AppSimulator(openai_api_key=openai_api_key)
 
-# Gradio Interface
-with gr.Blocks(js=js_func) as demo:
+def is_valid_input(user_input):
+    """Validate user input format."""
+    pattern = r"^\d+\.\s+.*"
+    return bool(re.match(pattern, user_input))
+
+def chat(user_input, history):
+    """Chat handler that validates input and interacts with the simulator."""
+    if is_valid_input(user_input):
+        valid_response = simulator_app.chat_interaction(user_input, history)
+        return valid_response
+    else:
+        invalid_response = "Invalid input. Please use the format: '<Number>. <Description>: query'"
+        return invalid_response
+
+css = """
+body { 
+    background-color: black !important; 
+    color: white; 
+}
+.gradio-container { 
+    background-color: black !important; 
+}
+.chatbox-message, input {
+    color: white !important;
+}
+"""
+
+# Gradio Interface using ChatInterface
+with gr.Blocks(fill_height=True, css=css) as demo:
     gr.Markdown("## Simulator Setup")
 
+    # Input fields for initialization
     task_input = gr.Textbox(label="Task", placeholder="Describe your task...")
     app_name_input = gr.Textbox(label="App Name", placeholder="Enter the app name...")
     sitemap_input = gr.Textbox(label="Sitemap", placeholder="Enter the Hugging Face link to sitemap...")
-
     initialize_button = gr.Button("Initialize Simulator")
-    chatbot = gr.Chatbot(label="Simulator Chat", height=800)
-    user_message = gr.Textbox(label="Enter your message", placeholder="Type your message here...")
-    submit_button = gr.Button("Send")
 
-    # Initialize simulator and display the welcome message
+    # Status block to display initialization progress with elapsed time
+    status = gr.Textbox(label="Status", interactive=False)
+
+    # Chat interface to handle user interactions
+    chat_interface = gr.ChatInterface(fn=chat)
+
+    # Define the callback function to initialize the simulator and update status
+    def initialize_and_start_chat(task, app_name, sitemap):
+        return simulator_app.initialize_simulator(task, app_name, sitemap)  # Use progress tracking
+
+    # Set up the button click to initialize simulator and update status only
     initialize_button.click(
-        simulator_app.initialize_simulator,
+        fn=initialize_and_start_chat,
         inputs=[task_input, app_name_input, sitemap_input],
-        outputs=chatbot
-    )
-
-    # Handle conversation interaction
-    submit_button.click(
-        simulator_app.chatbot_interaction,
-        inputs=user_message,
-        outputs=chatbot
+        outputs=status  # Update only the status block
     )
 
-# Launch the Gradio app
-demo.launch()
+# Launch the app
+demo.launch()

chatbot_simulator.py

@@ -59,12 +59,11 @@ You are at the {current_page} page. You have the following options:
 3. Feature 3
 4. Feature 4
 
-Please enter your choice as the corresponding number. If you have a query, enter as number: query
+Please enter your choice as 'Number. Description'. If you have a query, enter as 'Number. Description: query'
 
 Rules:
 - Be sure to display all options that is available in features. 
 - Be robotic and emotionless. Avoid offering any advice to the user.
-- If a feature requires `input_text`, request input as: "Enter query as: [number]: query"
         """
 
     def _get_openai_response(self, prompt):
@@ -74,7 +73,7 @@ Rules:
             model="gpt-4",
             messages=prompt,
             max_tokens=self.buffer_tokens,  # Adjusted max_tokens if needed
-            temperature=1.0,
+            temperature=0,
         )
         return response.choices[0].message.content
 
@@ -84,8 +83,8 @@ Rules:
 
     def _trim_conversation(self):
         """Trim the conversation to keep it within the token limit."""
-        while self._calculate_token_count(self.conversation) > self.max_tokens - self.buffer_tokens:
-            self.conversation.pop(0)  #
+        while self._calculate_token_count(self.conversation) >= (self.max_tokens - self.buffer_tokens * 4):
+            self.conversation.pop(0)
 
     def one_conversation_round(self, user_input):
         """Conduct one round of conversation between the user and the assistant."""
@@ -95,26 +94,22 @@ Rules:
 
         # Update user state using GPT's response
         update_prompt = f"""
-Update the user state based on user input: '{user_input}' and task: {self.task}
-
-Current user state (JSON format): {self.user_state}
-
+If user takes action '{user_input}' on {self.user_state['current_page']} page, which page will they move it?
+Recall user's task: {self.task}
+Update the user_state dictionary based on user's last action:
+Current user_state: {self.user_state}
 Sitemap: {self.sitemap}
 
 Instructions:
 1. If the 'current_page' has changed, update it to a page from the sitemap.
-2. If the task is finished, update 'task_completed' to 1. Otherwise, leave it unchanged.
+2. If the task is finished, update 'task_completed' to 1. Otherwise, leave it as 0.
 3. If no updates are needed, return the user state exactly as provided, without modification.
-4. Preserve the **exact JSON structure** and **format** of the provided user state.
-5. The output **must be a single JSON dictionary** representing the updated user state—do not wrap it in a list.
-6. Do not change any other fields unless explicitly required by the instructions.
 
 Important:
 - Ensure 'current_page' and 'task_completed' are keys in the returned dictionary.
-- Return **only the JSON object** without additional output or wrapping.
-- **AVOID OUTPUT A LIST**, must be JSON!
+- Return only the dictionary without additional output or wrapping.
 
-Example Format:
+Example Output Format:
 {{
     'current_page': 'Home',
     'task_completed': 0,
@@ -127,20 +122,24 @@ Example Format:
         # Parse and update the user state
         updated_state = json_repair.loads(updated_state)
 
-        if isinstance(updated_state, list):
-            reformat_prompt = f'''
-Given the {updated_state}, reformat it into a proper JSON.
-Make sure follow the format:
-{{
-    'current_page': 'Home',
-    'task_completed': 0,
-}}
-            '''
-            reformat_state = self._get_openai_response([{"role": "assistant", "content": reformat_prompt}])
-            updated_state = json_repair.loads(reformat_state)
-
-        if updated_state['task_completed']:
-            return f"Task completed! You took {self.prompt_count} steps."
+#         if isinstance(updated_state, list):
+#             reformat_prompt = f'''
+# Given the {updated_state}, reformat it into a proper JSON.
+# Make sure follow the format:
+# {{
+#     'current_page': 'Home',
+#     'task_completed': 0,
+# }}
+#             '''
+#             self.conversation.append({"role": "assistant", "content": reformat_prompt})
+#             reformat_state = self._get_openai_response(self.conversation)
+#             updated_state = json_repair.loads(reformat_state)
+
+        try:
+            if updated_state['task_completed']:
+                return f"Task completed! You took {self.prompt_count} steps."
+        except:
+            updated_state['task_completed'] = 0
 
         self.user_state = updated_state
 

task_specific_data_population.py

@@ -17,15 +17,6 @@ class DataPopulation:
                 )
             }
         ]
-        self.feature_update_conversation = [
-            {
-                "role": "system",
-                "content": (
-                    "You are an intelligent assistant specialized in web page management tasks. "
-                    "Your responsibilities is to identify which type of actions (select vs text_input) does each feature represents."
-                )
-            }
-        ]
 
     def fetch_huggingface_dataset(self, dataset_name):
         """Fetch the dataset from Hugging Face."""
@@ -37,7 +28,7 @@ class DataPopulation:
             model="gpt-4",
             messages=conversation,
             max_tokens=1000,  # Adjusted max_tokens if needed
-            temperature=1.0,
+            temperature=0,
         )
         return response.choices[0].message.content.strip()
 
@@ -122,7 +113,10 @@ class DataPopulation:
         self.conversation.append({"role": "assistant", "content": updated_user_data})
         updated_user_data = json_repair.loads(updated_user_data)
         for uid, page_data in updated_user_data.items():
-            page_details[uid]['user_data'] = page_data['user_data']
+            try:
+                page_details[uid]['user_data'] = page_data['user_data']
+            except:
+                continue
 
         # Step 5: Update user state
         updated_user_state = self.ask_to_update_user_state(task, user_state)