initial commit

README.md

@@ -1,13 +1,10 @@
 ---
 title: App Simulator
-emoji: 🏃
-colorFrom: indigo
-colorTo: purple
+emoji: 🐢
+colorFrom: red
+colorTo: indigo
 sdk: gradio
-sdk_version: 5.4.0
+sdk_version: 4.44.1
 app_file: app.py
 pinned: false
-short_description: simulate any real word app as a text-based chatbot
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,109 @@
+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 = []
+
+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
+
+    while not success and retry_count < max_retries:
+        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)
+            display_conversation.append(('Start Simulator', text))
+            display_conversation.pop(0)
+            return display_conversation
+        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))
+        display_conversation.pop(0)
+        return display_conversation
+    except Exception as e:
+        return f"An error occurred: {e}"
+
+
+# Gradio Interface
+with gr.Blocks() as demo:
+    gr.Markdown("## Simulator Setup")
+
+    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")
+    #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_button.click(
+        initialize_simulator,
+        inputs=[task_input, app_name_input, sitemap_input],
+        outputs=chatbot  # Show setup message in the chatbot
+    )
+
+    # Handle conversation
+    submit_button.click(
+        chatbot_interaction,
+        inputs=user_message,
+        outputs=chatbot
+    )
+
+# Launch the app
+demo.launch()

chatbot_simulator.py

@@ -0,0 +1,199 @@
+from openai import OpenAI
+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):
+        self.sitemap = site_map
+        self.page_details = page_details
+        self.user_state = user_state
+        self.user_state['current_page'] = 'Home'  # Initialize current page
+        self.user_state['task_completed'] = 0
+        self.task = task
+        self.app_name = app_name
+        self.log_location = log_location
+        self.agent = agent.lower()
+        if self.agent not in ['human', 'llm']:
+            raise ValueError("Invalid agent type. Expected 'Human' or 'llm'.")
+        self.max_steps = max_steps
+        self.max_tokens = max_tokens
+        self.buffer_tokens = buffer_tokens
+        self.conversation = []  # Stores recent conversation snippets
+        self.prompt_count = 0
+        self.client = OpenAI(api_key=openai_api_key)
+        self.actions = []
+
+    def _get_page_uid(self, page_name):
+        """Retrieve the UID of the given page from the sitemap."""
+        return self.sitemap['pages'].get(page_name, {}).get('uid')
+
+    def _get_page_details(self, page_name):
+        """Retrieve the page details using its UID."""
+        uid = self._get_page_uid(page_name)
+        return self.page_details.get(uid, {})
+
+    def _generate_system_prompt(self):
+        """Create a dynamic system prompt based on the current state."""
+        current_page = self.user_state['current_page']
+        page_info = self._get_page_details(current_page)
+
+        return f"""
+You are interacting with the {self.app_name} app. Your task is: {self.task}.
+You are currently on the {current_page} page. Current user state: {self.user_state}.
+
+Page Information:
+{page_info}
+
+- **Features**: Represent available options the user can select on this page.
+- **User Data**: Represents user-specific data accessible on this page.
+
+Provide instructions or request input from the user. If the user provides an invalid action, respond with:
+"Invalid action. Please select a valid option."
+
+### Instruction Format:
+You are at the {current_page} page. You have the following options:
+1. Feature 1
+2. Feature 2
+3. Feature 3
+4. Feature 4
+
+Please enter your choice as the corresponding number.
+
+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):
+        """Fetch response from OpenAI API."""
+        self._trim_conversation()
+        response = self.client.chat.completions.create(
+            model="gpt-4",
+            messages=prompt,
+            max_tokens=1500,  # Adjusted max_tokens if needed
+            temperature=1.0,
+        )
+        return response.choices[0].message.content
+
+    def _calculate_token_count(self, conversation):
+        """Estimate the token count in the conversation."""
+        return sum(len(entry['content'].split()) for entry in conversation)
+
+    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)  #
+
+    def one_conversation_round(self, user_input):
+        """Conduct one round of conversation between the user and the assistant."""
+        # User provides input
+        self.conversation.append({"role": "user", "content": user_input})
+        self.actions.append(user_input)
+
+        # Update user state using GPT's response
+        update_prompt = f"""
+        Update the user state based on the input: '{user_input}'.
+
+        Current user state (JSON format): {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.
+        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!
+        
+        The format for each page should be:
+        
+        {{
+            "page_name": page_name
+            "features": {{}},
+            "user_data": {{
+                "Data Entry 1": "Details of Data Entry 1", 
+                "Data Entry 2": "Details of Data Entry 2"
+            }}
+        }}
+        """
+
+        self.conversation.append({"role": "assistant", "content": update_prompt})
+        updated_state = self._get_openai_response(self.conversation)
+
+        # 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
+            with only 3 keys: page_name, features, user_data
+            Follow the format:
+             {{
+            "page_name": page_name
+            "features": {{}},
+            "user_data": {{
+                "Data Entry 1": "Details of Data Entry 1", 
+                "Data Entry 2": "Details of Data Entry 2"
+                }}
+            }}
+            '''
+            self.conversation.append({"role": "assistant", "content": reformat_prompt})
+            reformat_state = self._get_openai_response(self.conversation)
+            updated_state = json_repair.loads(reformat_state)
+
+        if updated_state['task_completed']:
+            return f"Task completed! You took {self.prompt_count} steps."
+
+        self.user_state = updated_state
+
+        system_prompt = self._generate_system_prompt()
+
+        # GPT generates the page instructions
+        self.conversation.append({"role": "system", "content": system_prompt})
+        gpt_instruction = self._get_openai_response(self.conversation)
+        self.conversation.append({"role": "assistant", "content": gpt_instruction})
+        return gpt_instruction
+
+    def _generate_agent_input(self):
+        """
+        Simulate the agent generating input based on the conversation state.
+        """
+        agent_prompt = f"""
+        Imagine you are an agent navigate through the Uber environment.
+        Your overarching task is: {self.task}. You may have done some part of the task, or none at all.
+        You will have access to all of your previous actions in the environment, as well as the last message from the assistant giving the current state of the environment.
+        The last message from the assistant was: {self.conversation[-1]['content']}
+        Respond first with a brief "Plan" which suggests what steps you are going to take to accomplish the task, and what your immediate. 
+        Then generate an "Action" which is the immediate next step you can take.
+        """
+
+        messages = [{"role": "system", "content": agent_prompt}]
+        for action in self.actions:
+            messages.append({"role": "user", "content": action})
+        messages.append({"role": "assistant", "content": self.conversation[-1]['content']})
+
+        agent_response = self.client.chat.completions.create(
+            model="gpt-4",
+            messages=messages,
+            temperature=1.0,
+        )
+        print(f"LLM-Agent: {agent_response.choices[0].message.content}")
+        return agent_response.choices[0].message.content
+
+    def start_conversation(self):
+        greeting = f'\n Welcome to {self.app_name} simulator! Your task is: {self.task}. \n'
+        system_prompt = self._generate_system_prompt()
+        # GPT generates the page instructions
+        self.conversation.append({"role": "system", "content": system_prompt})
+        gpt_instruction = self._get_openai_response(self.conversation)
+        self.conversation.append({"role": "assistant", "content": gpt_instruction})
+        return greeting + gpt_instruction

requirements.txt

@@ -0,0 +1,3 @@
+datadreamer.dev==0.38.0
+huggingface-hub==0.24.7
+json_repair

task_specific_data_population.py

@@ -0,0 +1,150 @@
+# task = task_generation(sitemap)
+from openai import OpenAI
+from datasets import load_dataset
+import json_repair
+
+
+class DataPopulation:
+    def __init__(self, api_key):
+        # Set the API key during initialization
+        self.client = OpenAI(api_key=api_key)
+        self.conversation = [
+            {
+                "role": "system",
+                "content": (
+                    "You are an intelligent assistant specialized in web page management tasks. "
+                    "Your responsibilities include identifying relevant pages, updating page details, user data, and the sitemap as required."
+                )
+            }
+        ]
+        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."""
+        return load_dataset(dataset_name)
+
+    def gpt4_chat(self, conversation):
+        """Send a chat request to GPT-4."""
+        response = self.client.chat.completions.create(
+            model="gpt-4",
+            messages=conversation,
+            max_tokens=1000,  # Adjusted max_tokens if needed
+            temperature=1.0,
+        )
+        return response.choices[0].message.content.strip()
+
+    def ask_for_relevant_pages(self, task, sitemap):
+        """Identify relevant pages for the task from the sitemap."""
+        self.conversation.append({
+            "role": "user",
+            "content": (
+                f"Given the task: '{task}' and the sitemap:\n{sitemap}\n\n"
+                "Identify the page(s) relevant to this task. "
+                "Return the page names exactly as they appear in the sitemap, in JSON format. "
+                "For each relevant page, provide a brief explanation of its relevance. "
+                "Example response:\n{{\n  'Ride History': 'Displays previous ride data needed for the task.'\n}}"
+            )
+        })
+        response_content = self.gpt4_chat(self.conversation)
+        return response_content
+
+    def _update_user_data(self, task, relevant_page_details):
+        """Populate the relevant user data for the task."""
+        self.conversation.append({
+            "role": "user",
+            "content": (
+                f"Given the task: '{task}' and the following page details:\n{relevant_page_details}\n\n"
+                "Instructions:\n"
+                "1. Ensure each page contains the following keys: 'page_name', 'features', and 'user_data' (even if empty).\n"
+                "2. Update 'user_data' with essential information relevant to the task. Do not modify the 'features' section.\n"
+                "3. Maintain the exact input structure, making changes only to 'user_data' where required.\n"
+                "4. Confirm that both 'features' and 'user_data' are dictionaries.\n"
+                "5. Verify that every page includes exactly the three required keys: 'page_name', 'features', and 'user_data'."
+                "6. Make sure 'user_data' must exist as a key! "
+            )
+        })
+        response_content = self.gpt4_chat(self.conversation)
+        return response_content
+
+    def ask_to_update_sitemap(self, sitemap, new_page):
+        """Update the sitemap with the new page and adjust links."""
+        self.conversation.append({
+            "role": "user",
+            "content": (
+                f"Given the current sitemap:\n{sitemap}\nand a new page: '{new_page}' (currently only has a 'uid'), update the sitemap by:\n"
+                "- Adding necessary details to '{new_page}', including 'links_to'.\n"
+                "- Updating 'links_to' in other relevant pages to include '{new_page}'.\n"
+                "Ensure the output retains the exact structure of the input."
+            )
+        })
+        response_sitemap = self.gpt4_chat(self.conversation)
+        return json_repair.loads(response_sitemap)
+
+    def ask_to_update_user_state(self, task, user_state):
+        """Update the user state based on the task."""
+        self.conversation.append({
+            "role": "user",
+            "content": (
+                f"Given the task: '{task}' and the current user state:\n{user_state}\n\n"
+                "Update the user state to reflect any changes necessary for completing the task. "
+                "Only modify values that are required; maintain the exact structure of the input."
+            )
+        })
+        response_content = self.gpt4_chat(self.conversation)
+        return json_repair.loads(response_content)
+
+    @staticmethod
+    def extract_uid_from_sitemap(sitemap, relevant_pages):
+        """Extract UIDs for the relevant pages from the sitemap."""
+        uid = []
+        for page in relevant_pages:
+            try:
+                uid.append(sitemap['pages'][page]['uid'])
+            except KeyError:
+                print(f"Page name '{page}' not found in the sitemap.")
+        return uid
+
+    def process_data(self, task, hugging_face_url):
+        """Process the task with the given dataset."""
+        dataset = self.fetch_huggingface_dataset(hugging_face_url)
+
+        # Extract the sitemap, page details, and user state from the dataset
+        sitemap = eval(dataset['train'][0]['value'])
+        page_details = eval(dataset['train'][1]['value'])
+        user_state = eval(dataset['train'][2]['value'])
+
+        # Step 1: Identify relevant pages
+        relevant_pages = self.ask_for_relevant_pages(task, sitemap)
+        self.conversation.append({"role": "assistant", "content": relevant_pages})
+        relevant_pages = json_repair.loads(relevant_pages)
+        target_page_names = relevant_pages.keys()
+
+        # Step 2: Extract UIDs for the relevant pages
+        page_uid = self.extract_uid_from_sitemap(sitemap, target_page_names)
+
+        # Step 3: Retrieve page details using the UIDs
+        relevant_page_details = {
+            uid: page_details[uid] for uid in page_uid if uid in page_details
+        }
+
+        # Step 4: Populate user data for the task (only for relevant pages)
+        updated_user_data = self._update_user_data(task, relevant_page_details)
+        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']
+
+        # Step 5: Update user state
+        updated_user_state = self.ask_to_update_user_state(task, user_state)
+
+        # Return the updated structures
+        return sitemap, page_details, updated_user_state