initial commit

README.md

@@ -1,7 +1,7 @@
 ---
 title: App Simulator
-emoji: 🐢
-colorFrom: red
+emoji: 🎮
+colorFrom: purple
 colorTo: indigo
 sdk: gradio
 sdk_version: 4.44.1

app.py

@@ -2,84 +2,103 @@ import gradio as gr
 from chatbot_simulator import ChatbotSimulation
 from task_specific_data_population import DataPopulation
 import os
+
 openai_api_key = os.getenv("OPENAI_API_KEY")
 
 
-simulation = None
-conversation = []
-display_conversation = []
+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
+        retry_count = 0
+        max_retries = 50
+
+        while not success and retry_count < max_retries:
+            try:
+                # Process data
+                data_population = DataPopulation(api_key=self.openai_api_key)
+                sitemap_data, page_details, user_state = data_population.process_data(task, sitemap)
+
+                self.simulation = ChatbotSimulation(
+                    site_map=sitemap_data,
+                    page_details=page_details,
+                    user_state=user_state,
+                    task=task,
+                    app_name=app_name,
+                    log_location=f'conversation_log_{app_name}_human.txt',
+                    openai_api_key=self.openai_api_key,
+                    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
+            except Exception as e:
+                retry_count += 1
+                print(f"Attempt {retry_count}/{max_retries}: An error occurred: {e}. Retrying...")
+
+    def chatbot_interaction(self, user_input):
+        """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 initialize_simulator(task, app_name, sitemap):
-    """Initialize the simulator."""
-    success = False  # Track if the operation succeeds
-    retry_count = 0  # Track the number of retries
-    max_retries = 50  # Set the maximum number of retries
+    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)
 
-    while not success and retry_count < max_retries:
+    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:
-            # Process data (simulating data loading)
-            data_population = DataPopulation(api_key=openai_api_key)
-            sitemap_data, page_details, user_state = data_population.process_data(task, sitemap)
-
-            global simulation
-            simulation = ChatbotSimulation(
-                site_map=sitemap_data,
-                page_details=page_details,
-                user_state=user_state,
-                task=task,
-                app_name=app_name,
-                log_location=f'conversation_log_{app_name}_human.txt',
-                openai_api_key=openai_api_key,
-                agent='human'
-            )
-            text = simulation.start_conversation()
-            global conversation
-            conversation.append({"role": "assistant", "content": text})
-            log_conversation(simulation.log_location)
-
-            global display_conversation
-            display_conversation.append(('Start Simulator', text))
-            if len(display_conversation) > 2:
-                display_conversation.pop(0)
-            return display_conversation
+            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:
-            # Handle the exception and increment retry count
-            retry_count += 1
-            print(f"Attempt {retry_count}/{max_retries}: An error occurred: {e}. Retrying...")
-
-
-def log_conversation(log_location):
-    """
-    Append the conversation to the specified log file location.
-    """
-    try:
-        with open(log_location, 'a') as f:  # Use 'a' for append mode
-            for message in conversation:
-                f.write(f"{message['role']}: {message['content']}\n\n")
-    except Exception as e:
-        print(f"Error logging conversation: {e}")
-
-
-def chatbot_interaction(user_input):
-    """Handle the conversation."""
-    if simulation is None:
-        return "Simulation is not initialized. Please start the simulator."
-
-    try:
-        # Perform one round of conversation
-        response = simulation.one_conversation_round(user_input)
-        global conversation
-        conversation.append({"role": "user", "content": user_input})
-        conversation.append({"role": "assistant", "content": response})
-        log_conversation(simulation.log_location)
-        display_conversation.append((user_input, response))
-        return display_conversation
-    except Exception as e:
-        return f"An error occurred: {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;
+    }
+}
+"""
+
+simulator_app = AppSimulator(openai_api_key=openai_api_key)
+
 # Gradio Interface
-with gr.Blocks() as demo:
+with gr.Blocks(js=js_func) as demo:
     gr.Markdown("## Simulator Setup")
 
     task_input = gr.Textbox(label="Task", placeholder="Describe your task...")
@@ -87,25 +106,23 @@ with gr.Blocks() as demo:
     sitemap_input = gr.Textbox(label="Sitemap", placeholder="Enter the Hugging Face link to sitemap...")
 
     initialize_button = gr.Button("Initialize Simulator")
-    #setup_output = gr.Textbox(label="Setup Status", interactive=False)
-
     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 in chatbot
+    # Initialize simulator and display the welcome message
     initialize_button.click(
-        initialize_simulator,
+        simulator_app.initialize_simulator,
         inputs=[task_input, app_name_input, sitemap_input],
-        outputs=chatbot  # Show setup message in the chatbot
+        outputs=chatbot
     )
 
-    # Handle conversation
+    # Handle conversation interaction
     submit_button.click(
-        chatbot_interaction,
+        simulator_app.chatbot_interaction,
         inputs=user_message,
         outputs=chatbot
     )
 
-# Launch the app
+# Launch the Gradio app
 demo.launch()

chatbot_simulator.py

@@ -5,7 +5,7 @@ import json_repair
 class ChatbotSimulation:
     def __init__(self, site_map, page_details, user_state, task,
                  app_name, log_location, openai_api_key, agent='human',
-                 max_steps=50, max_tokens=8192, buffer_tokens=500):
+                 max_steps=50, max_tokens=8192, buffer_tokens=1000):
         self.sitemap = site_map
         self.page_details = page_details
         self.user_state = user_state
@@ -73,7 +73,7 @@ Rules:
         response = self.client.chat.completions.create(
             model="gpt-4",
             messages=prompt,
-            max_tokens=1500,  # Adjusted max_tokens if needed
+            max_tokens=self.buffer_tokens,  # Adjusted max_tokens if needed
             temperature=1.0,
         )
         return response.choices[0].message.content
@@ -84,7 +84,7 @@ 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:
+        while self._calculate_token_count(self.conversation) > self.max_tokens - (self.buffer_tokens+500):
             self.conversation.pop(0)  #
 
     def one_conversation_round(self, user_input):