browsergym-workarena 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

browsergym/workarena/tasks/compositional/offboard_user.py

@@ -0,0 +1,207 @@
+import json
+
+from faker import Faker
+
+fake = Faker()
+from playwright.sync_api._generated import Page
+
+from .base import CompositionalTask, HumanEvalTask
+from .delete_record import DeleteUserTask
+
+from ..base import AbstractServiceNowTask
+from ..form import EditHardwareAssetTask
+from ..knowledge import KnowledgeBaseSearchTask
+from ..list import FilterHardwareListTask
+from ..navigation import AllMenuTask
+
+from ...api.computer_asset import create_computer_asset
+from ...api.user import create_user
+from ...api.utils import table_api_call, db_delete_from_table
+from ...instance import SNowInstance
+
+
+class OffBoardUserTask(CompositionalTask, HumanEvalTask):
+    def __init__(
+        self,
+        seed: int = None,
+        instance: SNowInstance = None,
+        fixed_config: list[AbstractServiceNowTask] = None,
+        level: int = 2,
+    ) -> None:
+        """
+        Employee OffBoarding Task
+
+        Parameters:
+        -----------
+        instance: SNowInstance
+            The ServiceNow instance to run the task on.
+        fixed_config: list[AbstractServiceNowTask]
+            A list of subtasks.
+        level: int
+            The level of the task; choice between 2 and 3. L2 will have all the info in the the goal and start in the SNOW home page.
+            L3 will start in a private task page describing the information needed to complete the task and the related company protocol
+            to complete it.
+        Attributes:
+        -----------
+        task_description: str
+            The start of the task description to be completed. e.g. "Referring to company protocol 'Offboarding a user', offboard user XYZ"
+        short_description: str
+            A short description of the task to be completed. e.g. "Offboard user John Doe"
+        """
+        assert level in [2, 3], "Level must be either 2 or 3"
+        self.level = level
+        self.protocol_name = "Offboarding a user"
+        super().__init__(
+            seed=seed,
+            instance=instance,
+            fixed_config=fixed_config,
+            level=level,
+            protocol_name=self.protocol_name,
+        )
+        self.task_description = None
+        self.short_description = None
+        self.user_full_name = None
+        self.user_sys_id = None
+        self.user_name = None
+        self.laptop_asset_tag = None
+        self.laptop_sys_id = None
+
+    def setup_goal(self, page: Page) -> tuple[str, dict]:
+        # Generate random name for the user
+        first_name = fake.first_name() + "-" + fake.first_name()
+        last_name = fake.last_name() + "-" + fake.last_name()
+        self.user_full_name = first_name + " " + last_name
+        self.laptop_asset_tag = "P" + str(id(self) % (10**8)).zfill(8)
+
+        # Create user
+        self.user_name, _, self.user_sys_id = create_user(
+            instance=self.instance, first_name=first_name, last_name=last_name, random=self.random
+        )
+
+        assert self.user_sys_id, f"Failed to create user {first_name} {last_name}"
+
+        self.laptop_sys_id, _, _ = create_computer_asset(
+            instance=self.instance,
+            asset_tag=self.laptop_asset_tag,
+            user_sys_id=self.user_sys_id,
+            random=self.random,
+        )
+
+        config = self.fixed_config if self.fixed_config else self._get_config()
+        # Get the task description
+        self.short_description = f"Offboard user {self.user_full_name}"
+        self.task_description = f'Referring to company protocol "{self.protocol_name}" (located in the "Company Protocols" knowledge base) offboard user "{self.user_full_name}" \n'
+
+        goal, info = super().setup_goal(page=page, config=config)
+
+        return goal, info
+
+    def _get_config(self) -> list[AbstractServiceNowTask]:
+        """Sample a user configuration and a hardware asset configuration. Add the assigned_to field if missing
+        from the hardware asset configuration. Finally, return the list of subtasks, with navigation subtasks included.
+        """
+        navigate_to_protocol_subtask = [
+            # Navigate to the KB
+            AllMenuTask(
+                instance=self.instance,
+                fixed_config={
+                    "application": "Self-Service",
+                    "module": "Knowledge",
+                    "url": "/now/nav/ui/classic/params/target/%24knowledge.do",
+                },
+                is_validated=False,
+                used_in_level_2=False,
+            ),
+            # Find the protocol for on-boarding a new user
+            KnowledgeBaseSearchTask(
+                instance=self.instance,
+                fixed_config={
+                    "alternative_answers": [],
+                    "item": f"{self.protocol_name}",
+                    "question": f'Can you find the "{self.protocol_name}" Protocol in the Knowledge Base?',
+                    "value": "",
+                },
+                is_validated=False,
+                used_in_level_2=False,
+            ),
+        ]
+        unassign_hardware_subtask = [
+            # Navigate to the hardware asset list
+            AllMenuTask(
+                instance=self.instance,
+                fixed_config={
+                    "application": "Asset",
+                    "module": "Portfolios > Hardware Assets",
+                    "url": "/now/nav/ui/classic/params/target/alm_hardware_list.do",
+                },
+                is_validated=False,
+                used_in_level_2=True,
+            ),
+            FilterHardwareListTask(
+                instance=self.instance,
+                fixed_config={
+                    "filter_columns": ["assigned_to"],
+                    "filter_kind": "AND",
+                    "filter_values": [f"{self.user_full_name}"],
+                },
+                is_validated=False,
+                used_in_level_2=True,
+            ),
+            # Create a new hardware asset
+            EditHardwareAssetTask(
+                instance=self.instance,
+                record_sys_id=self.laptop_sys_id,
+                new_values={"assigned_to": ""},
+                is_validated=True,
+                used_in_level_2=True,
+                level=self.level,
+            ),
+        ]
+        delete_user_subtask = [
+            # Navigate to the user list
+            AllMenuTask(
+                instance=self.instance,
+                fixed_config={
+                    "application": "System Security",
+                    "module": "Users and Groups > Users",
+                    "url": "/now/nav/ui/classic/params/target/sys_user_list.do",
+                },
+                is_validated=False,
+                used_in_level_2=True,
+            ),
+            # Create a new user
+            DeleteUserTask(
+                instance=self.instance,
+                fixed_config={
+                    "field_name": "name",
+                    "pretty_printed_field_name": "Name",
+                    "field_value": self.user_full_name,
+                    "other_fields": {},
+                },
+                record_sys_id=self.user_sys_id,
+                is_validated=True,
+                used_in_level_2=True,
+            ),
+        ]
+
+        config = navigate_to_protocol_subtask + unassign_hardware_subtask + delete_user_subtask
+
+        return config
+
+    def teardown(self) -> None:
+        # Delete the user
+        user_record = table_api_call(
+            instance=self.instance,
+            table="sys_user",
+            params={"sysparm_query": f"sys_id={self.user_sys_id}"},
+        )["result"]
+        if user_record:
+            db_delete_from_table(
+                instance=self.instance,
+                table="sys_user",
+                sys_id=self.user_sys_id,
+            )
+        super().teardown()
+
+
+__TASKS__ = [OffBoardUserTask]

browsergym/workarena/tasks/compositional/onboard_user.py

@@ -0,0 +1,226 @@
+import json
+
+from playwright.sync_api._generated import Page
+
+from .base import CompositionalTask, HumanEvalTask
+
+from ..base import AbstractServiceNowTask
+from ..form import CreateUserTask, CreateHardwareAssetTask
+from ..knowledge import KnowledgeBaseSearchTask
+from ..navigation import AllMenuTask
+from ..service_catalog import OrderAppleMacBookPro15Task
+
+from ...instance import SNowInstance
+from ...config import CREATE_USER_CONFIG_PATH, CREATE_HARDWARE_CONFIG_PATH
+
+
+class OnBoardUserTask(CompositionalTask, HumanEvalTask):
+    def __init__(
+        self,
+        seed: int = None,
+        instance: SNowInstance = None,
+        fixed_config: list[AbstractServiceNowTask] = None,
+        level: int = 2,
+    ) -> None:
+        """
+        Create a compositional task with specific subtasks
+
+        Parameters:
+        -----------
+        instance: SNowInstance
+            The ServiceNow instance to run the task on.
+        fixed_config: list[AbstractServiceNowTask]
+            A list of subtasks.
+        level: int
+            The level of the task; choice between 2 and 3. L2 will have all the info in the the goal and start in the SNOW home page.
+            L3 will start in a private task page describing the information needed to complete the task and the related company protocol
+            to complete it.
+        Attributes:
+        -----------
+        task_description: str
+            The start of the task description to be completed. e.g. "Referring to company protocol 'Onboarding a new user', onboard user with the following information: \n"
+        short_description: str
+            A short description of the task to be completed. e.g. "Onboard user John Doe"
+        """
+        assert level in [2, 3], "Level must be either 2 or 3"
+        self.level = level
+        self.protocol_name = "Onboarding a new user"
+        super().__init__(
+            seed=seed,
+            instance=instance,
+            fixed_config=fixed_config,
+            level=level,
+            protocol_name=self.protocol_name,
+        )
+
+        self.all_user_configs = CreateUserTask.all_configs()
+        self.all_hardware_asset_configs = CreateHardwareAssetTask.all_configs()
+        self.task_description = None
+        self.short_description = None
+
+    def setup_goal(self, page: Page) -> tuple[str, dict]:
+        # Sample a configuration
+        config = self.fixed_config if self.fixed_config else self._get_config()
+        user_name = (
+            config[3].fixed_config["template_record"]["first_name"]
+            + " "
+            + config[3].fixed_config["template_record"]["last_name"]
+        )
+        # Get the task description
+        self.short_description = f"Onboard user {user_name}"
+        self.task_description = f'Referring to company protocol "{self.protocol_name}" (located in the "Company Protocols" knowledge base) onboard user with the following information: \n'
+
+        goal, info = super().setup_goal(page=page, config=config)
+
+        return goal, info
+
+    def _get_config(self) -> list[AbstractServiceNowTask]:
+        # Sample base configurations; the hardware config will be modified to include the assigned_to field
+        user_config = self.random.choice(self.all_user_configs)
+        hardware_config = self.random.choice(self.all_hardware_asset_configs)
+
+        # Get the common fields between the user and hardware configurations to adjust the hardware config
+        common_fields = [
+            field for field in hardware_config["fields"].keys() if field in user_config["fields"]
+        ]
+        common_task_fields = [
+            field for field in hardware_config["task_fields"] if field in user_config["task_fields"]
+        ]
+        common_template_record_fields = [
+            field
+            for field in hardware_config["template_record"].keys()
+            if field in user_config["template_record"] and "sys" not in field
+        ]
+
+        # Drop the common fields as they create synchronization issues
+        for field in common_fields + common_task_fields + common_template_record_fields:
+            if field in user_config["fields"]:
+                user_config["fields"].pop(field)
+            if field in hardware_config["fields"]:
+                hardware_config["fields"].pop(field)
+
+            if field in user_config["task_fields"]:
+                user_config["task_fields"].remove(field)
+            if field in hardware_config["task_fields"]:
+                hardware_config["task_fields"].remove(field)
+
+            if field in user_config["template_record"]:
+                user_config["template_record"].pop(field)
+            if field in hardware_config["template_record"]:
+                hardware_config["template_record"].pop(field)
+
+        navigate_to_protocol_subtask = [
+            # Navigate to the KB
+            AllMenuTask(
+                instance=self.instance,
+                fixed_config={
+                    "application": "Self-Service",
+                    "module": "Knowledge",
+                    "url": "/now/nav/ui/classic/params/target/%24knowledge.do",
+                },
+                is_validated=False,
+                used_in_level_2=False,
+            ),
+            # Find the protocol for on-boarding a new user
+            KnowledgeBaseSearchTask(
+                instance=self.instance,
+                fixed_config={
+                    "alternative_answers": [],
+                    "item": f"{self.protocol_name}",
+                    "question": f"Can you find the '{self.protocol_name}' Protocol in the Knowledge Base?",
+                    "value": "",
+                },
+                is_validated=False,
+                used_in_level_2=False,
+            ),
+        ]
+
+        create_user_subtask = [
+            # Navigate to the user list
+            AllMenuTask(
+                instance=self.instance,
+                fixed_config={
+                    "application": "System Security",
+                    "module": "Users and Groups > Users",
+                    "url": "/now/nav/ui/classic/params/target/sys_user_list.do",
+                },
+                is_validated=False,
+                used_in_level_2=True,
+            ),
+            # Create a new user
+            CreateUserTask(
+                instance=self.instance,
+                fixed_config=user_config,
+                is_validated=True,
+                used_in_level_2=True,
+            ),
+        ]
+
+        order_hardware_subtask = [
+            # Navigate to the hardware asset list
+            AllMenuTask(
+                instance=self.instance,
+                fixed_config={
+                    "application": "Self-Service",
+                    "module": "Service Catalog",
+                    "url": "/now/nav/ui/classic/params/target/catalog_home.do",
+                },
+                is_validated=False,
+                used_in_level_2=True,
+            ),
+            # Order a MacBook Pro 15
+            OrderAppleMacBookPro15Task(
+                instance=self.instance,
+                fixed_config={
+                    "configuration": {},
+                    "description": "Apple MacBook Pro",
+                    "item": "Apple MacBook Pro 15",
+                    "quantity": 1,
+                },
+                is_validated=True,
+                used_in_level_2=True,
+            ),
+        ]
+        # The unique name for the user is created once the task is instantiated
+        user_full_name = (
+            create_user_subtask[1].template_record["first_name"]
+            + " "
+            + create_user_subtask[1].template_record["last_name"]
+        )
+        # Set the assigned_to field in the hardware asset configuration to the user's email
+        hardware_config["template_record"]["assigned_to"] = user_full_name
+        if "assigned_to" not in hardware_config["task_fields"]:
+            hardware_config["task_fields"].append("assigned_to")
+
+        create_hardware_subtask = [
+            # Navigate to the hardware asset list
+            AllMenuTask(
+                instance=self.instance,
+                fixed_config={
+                    "application": "Asset",
+                    "module": "Portfolios > Hardware Assets",
+                    "url": "/now/nav/ui/classic/params/target/alm_hardware_list.do",
+                },
+                is_validated=False,
+                used_in_level_2=True,
+            ),
+            # Create a new hardware asset
+            CreateHardwareAssetTask(
+                instance=self.instance,
+                fixed_config=hardware_config,
+                is_validated=True,
+                used_in_level_2=True,
+            ),
+        ]
+
+        config = (
+            navigate_to_protocol_subtask
+            + create_user_subtask
+            + order_hardware_subtask
+            + create_hardware_subtask
+        )
+
+        return config
+
+
+__TASKS__ = [OnBoardUserTask]

browsergym/workarena/tasks/compositional/update_task.py

@@ -0,0 +1,145 @@
+from playwright.sync_api import Page
+from typing import List, Tuple
+
+from ..base import AbstractServiceNowTask
+from ..comp_building_block import CompositionalBuildingBlockTask
+from ..utils.utils import check_url_suffix_match
+from ..utils.private_tasks import create_private_task_and_get_sys_id
+
+from ...api.utils import db_delete_from_table, table_api_call
+
+
+class UpdatePrivateTask(AbstractServiceNowTask, CompositionalBuildingBlockTask):
+    """
+    Set a private task to complete, assuming we start on the task viewed as form.
+
+    Parameters:
+    -----------
+    instance: SNowInstance
+        The instance to use.
+    start_rel_url: str
+        The relative URL of the task list.
+    fixed_config: dict
+        Configuration to use for the task. If provided, the task will use the provided configuration instead of
+        selecting a random one. See browsergym/workarena/data_files/task_configs/filter_change_request_list_task.json
+        for an example of a configuration file.
+    set_as_completed: bool
+        Whether the task should be marked as complete or not. If True, the task will be marked as complete; otherwise, marked as.
+        used to set infeasible tasks to incomplete.
+    """
+
+    def __init__(
+        self,
+        seed: int = None,
+        instance=None,
+        start_rel_url="/now/nav/ui/classic/params/target/task_list.do%3Fsysparm_userpref_module%3D1523b8d4c611227b00be8216ec331b9a%26sysparm_query%3Dactive%253Dtrue%255Eassigned_to%253Djavascript%253AgetMyAssignments%2528%2529%255Estate%2521%253D-5%255EEQ",
+        fixed_config: dict = None,
+        set_as_completed: bool = True,
+        **kwargs,
+    ) -> None:
+        super().__init__(seed=seed, instance=instance, start_rel_url=start_rel_url)
+        self.fixed_config = fixed_config
+        self.config = fixed_config
+        self.set_as_completed = set_as_completed
+        # 3 is the state for "Closed-Complete", 4 is "Closed-Incomplete", 7 is "Closed-Skipped"
+        self.allowed_options = ["3"] if self.set_as_completed else ["4", "7"]
+        self.private_task_id = "PTSK" + str(id(self) % (10**8)).zfill(8)
+        if self.fixed_config is None:
+            self.config = {
+                "task_description": "Close private task",
+                "short_description": self.private_task_id,
+            }
+        self.sys_id = None
+        self.task_rel_url = None  # Relative URL of the task in form view
+        self.__dict__.update(kwargs)
+
+    def setup_goal(self, page: Page) -> tuple[str, dict]:
+        task_description = self.config["task_description"]
+        short_description = self.config["short_description"]
+        self.sys_id = create_private_task_and_get_sys_id(
+            self.instance,
+            page,
+            self.private_task_id,
+            task_description,
+            short_description,
+            user_sys_id=self._base_user_sysid,
+        )
+        self.task_rel_url = (
+            f"/now/nav/ui/classic/params/target/vtb_task.do%3Fsys_id%3D{self.sys_id}"
+        )
+        goal = f"Close private task {self.private_task_id}"
+
+        return goal, {}
+
+    def get_pretty_printed_description(self) -> str:
+        """
+        Get the task info for this task when used in a private task; Used in L3 compositional tasks.
+        called by subclasses
+        """
+        task_info = "Don't forget to mark this task as complete once you're done."
+
+        return task_info
+
+    def cheat(self, page: Page, chat_messages: list[str]) -> None:
+        super().cheat(page, chat_messages)
+        frame = page.wait_for_selector('iframe[name="gsft_main"]').content_frame()
+        # Search for the private task by search for the number
+        frame.get_by_label("Search a specific field of the Tasks list").select_option("number")
+        search_input = frame.locator('input[aria-label="Search"]')
+        search_input.click()
+        search_input.fill(self.private_task_id)
+        search_input.press("Enter")
+        page.wait_for_timeout(1500)
+        # Click on the private task to open it
+        frame.get_by_label(f"Open record: {self.private_task_id}").click()
+        page.wait_for_timeout(2000)
+        page.wait_for_load_state("networkidle")
+        frame = page.wait_for_selector('iframe[name="gsft_main"]').content_frame()
+        page.wait_for_timeout(1500)
+        # Click on the task state, select "Closed-Complete" if complete, else "Closed Skipped" and update the task
+        option = "3" if self.set_as_completed else "7"
+        frame.get_by_label("state").first.select_option(option)
+        frame.get_by_text("update").first.click()
+        # Wait for record to be updated in the DB
+        record_updated = False
+        while not record_updated:
+            record = table_api_call(
+                instance=self.instance,
+                table="vtb_task",
+                params={"sysparm_query": f"task_effective_number={self.private_task_id}"},
+            )["result"]
+            record_updated = record[0]["state"] == option
+        page.wait_for_timeout(1000)
+
+    def validate(self, page: Page, chat_messages: list[str]) -> Tuple[float, bool, str, dict]:
+        """
+        Validate the solution
+        """
+        record = table_api_call(
+            instance=self.instance,
+            table="vtb_task",
+            params={"sysparm_query": f"task_effective_number={self.private_task_id}"},
+        )["result"]
+        if not record:
+            return 0, False, "", {"message": "Private task not found."}
+        if record[0]["state"] not in self.allowed_options:
+            return 0, False, "", {"message": "Private task not closed appropriately."}
+
+        return 1, True, "Nice work, thank you!", {"message": "Private task was closed."}
+
+    def teardown(self) -> None:
+        record_exists = table_api_call(
+            instance=self.instance,
+            table="vtb_task",
+            params={"sysparm_query": f"sys_id={self.sys_id}"},
+        )["result"]
+        if record_exists:
+            db_delete_from_table(
+                instance=self.instance,
+                table="vtb_task",
+                sys_id=self.sys_id,
+            )
+        super().teardown()
+
+
+__TASKS__ = [UpdatePrivateTask]