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

browsergym/workarena/tasks/list.py

@@ -15,6 +15,8 @@ from typing import List, Tuple
 from urllib import parse
 from warnings import warn
 
+from .comp_building_block import CompositionalBuildingBlockTask
+
 from ..api.utils import table_api_call, table_column_info
 from ..config import (
     SNOW_BROWSER_TIMEOUT,
@@ -35,6 +37,7 @@ from ..config import (
     EXPECTED_CHANGE_REQUEST_COLUMNS_PATH,
     EXPECTED_HARDWARE_COLUMNS_PATH,
     EXPECTED_INCIDENT_COLUMNS_PATH,
+    EXPECTED_PROBLEM_COLUMNS_PATH,
     EXPECTED_SERVICE_CATALOG_COLUMNS_PATH,
     EXPECTED_USER_COLUMNS_PATH,
 )
@@ -76,8 +79,34 @@ LISTS = {
     },
 }
 
+EXTRACT_USER_LIST_INFO_CONFIG = [
+    {
+        "start_rel_url": "/now/nav/ui/classic/params/target/sys_user_list.do%3Fsysparm_query%3Dactive%253Dtrue%255Ecompany%253D81fd65ecac1d55eb42a426568fc87a63%255Eemail%253Dlucius.bagnoli%40example.com%26sysparm_first_row%3D1%26sysparm_view%3D",
+        "fields": {
+            "user_name": "User ID",
+            "email": "Email",
+            "first_name": "First name",
+            "last_name": "Last name",
+        },
+        "expected_values": [
+            {
+                "user_name": "lucius.bagnoli",
+                "email": "lucius.bagnoli@example.com",
+                "first_name": "Lucius",
+                "last_name": "Bagnoli",
+            }
+        ],
+    }
+]
+
 
 class ServiceNowListTask(AbstractServiceNowTask):
+
+    @classmethod
+    def all_configs(cls) -> List[dict]:
+        with open(cls.config_path, "r") as f:
+            return json.load(f)
+
     def get_init_scripts(self) -> List[str]:
         return super().get_init_scripts() + ["registerGsftMainLoaded();"]
 
@@ -129,12 +158,10 @@ class ServiceNowListTask(AbstractServiceNowTask):
         }
 
         # Get column info
-        fields = list_info["fields"].split(",")
         list_info["columns"] = table_column_info(
             instance=self.instance,
             table=list_info["glide_table"],
         )
-        list_info["columns"] = {k: v for k, v in list_info["columns"].items() if k in fields}
 
         # Get the list data
         if with_data:
@@ -189,43 +216,46 @@ class SortListTask(ServiceNowListTask):
         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/sort_change_request_list_task.json
         for an example of a configuration file.
-    config_path:
-        The path to the JSON file containing all configurations for the task. Provided by subclasses
     expected_fields_path:
         The path to the JSON file containing all expected fields for the task. Provided by subclasses
     """
 
     def __init__(
         self,
-        seed: int,
+        seed: int = None,
         instance=None,
         list_url="",
         forbidden_fields=[],
         fixed_config: dict = None,
-        config_path: str = None,
         expected_fields_path: str = None,
+        **kwargs,
     ) -> None:
         super().__init__(seed=seed, instance=instance, start_rel_url=list_url)
         self.min_sort_len = 1
         self.max_sort_len = 3
         self.forbidden_fields = forbidden_fields
         self.fixed_config = fixed_config
-        if config_path:
-            with open(config_path, "r") as f:
-                self.all_configs = json.load(f)
+        self.config = None
+        if hasattr(self, "config_path"):
+            self.all_configs = self.all_configs()
+
         with open(expected_fields_path, "r") as f:
             self.expected_fields = set(json.load(f))
+        self.list_info = None
+        self.__dict__.update(kwargs)
 
     def setup_goal(self, page: Page) -> tuple[str, dict]:
         super().setup_goal(page=page)
 
         # Get the task configuration
-        config = self.fixed_config if self.fixed_config else self.random.choice(self.all_configs)
-        self.sort_fields = config["sort_fields"]
-        self.sort_dirs = config["sort_dirs"]
+        self.config = (
+            self.fixed_config if self.fixed_config else self.random.choice(self.all_configs)
+        )
+        self.sort_fields = self.config["sort_fields"]
+        self.sort_dirs = self.config["sort_dirs"]
 
         # Get the task goal
-        goal = config["goal"]
+        goal = self.config["goal"]
         info = {}
 
         return goal, info
@@ -236,10 +266,13 @@ class SortListTask(ServiceNowListTask):
 
         # Ensure that the fields that need to be sorted are visible (task feasibility check)
         self.list_info = self._extract_list_info(page)
-        visible_columns = set(self.list_info["fields"].split(","))
-        assert (
-            set(self.sort_fields) <= visible_columns and visible_columns == self.expected_fields
-        ), f"Fields {self.sort_fields} are not all visible in the list. Re-run workarena-install to correct this."
+
+    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
+        """
+        return self.config["goal"] + "\n"
 
     def _generate_all_configs(self, seed: int, page: Page, n_fields_to_sort: int):
         self.setup(seed=seed, page=page)
@@ -311,7 +344,7 @@ class SortListTask(ServiceNowListTask):
             sort_dirs_txt = [dir_txt[sort_dir] for sort_dir in self.sort_dirs]
 
             # check if the task is already solved (can happen if the chosen field is already sorted in the default view)
-            _, done, _, _ = self.validate(self.page, [])
+            _, done, _, _ = self.validate(page, [])
             # if so, pick new fields
             if done:
                 logging.warning("Trivial config for sort list task, picking a new config.")
@@ -329,6 +362,8 @@ class SortListTask(ServiceNowListTask):
     def cheat(self, page: Page, chat_messages: list[str]) -> None:
         super().cheat(page=page, chat_messages=chat_messages)
         self._wait_for_ready(page)
+        if self.list_info is None:
+            self.list_info = self._extract_list_info(page)
 
         iframe, _, _ = self._get_visible_list(page)
 
@@ -408,8 +443,8 @@ class SortListTask(ServiceNowListTask):
             # ... retrieve list
             list_info = self._extract_list_info(page)
             # ... get sorting info
-            sort_by = self.page.evaluate(f'{list_info["js_selector"]}.getOrderBy()')
-            sort_dir = self.page.evaluate(f'{list_info["js_selector"]}.sortDir')
+            sort_by = page.evaluate(f'{list_info["js_selector"]}.getOrderBy()')
+            sort_dir = page.evaluate(f'{list_info["js_selector"]}.sortDir')
             # ... check if the list is sorted correctly
             if sort_by == self.sort_fields[0] and sort_dir.lower() == self.sort_dirs[0]:
                 return (
@@ -469,30 +504,31 @@ class FilterListTask(ServiceNowListTask):
         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.
-    config_path:
-        The path to the JSON file containing all configurations for the task. Provided by subclasses
     expected_fields_path:
         The path to the JSON file containing all expected fields for the task. Provided by subclasses
     """
 
     def __init__(
         self,
-        seed: int,
+        seed: int = None,
         instance=None,
         list_url="",
         fixed_config: dict = None,
-        config_path: str = None,
         expected_fields_path: str = None,
+        **kwargs,
     ) -> None:
         self.min_filter_len = 2
         self.max_filter_len = 5
         super().__init__(seed=seed, instance=instance, start_rel_url=list_url)
         self.fixed_config = fixed_config
-        if config_path:
-            with open(config_path, "r") as f:
-                self.all_configs = json.load(f)
+        self.config = None
+        if hasattr(self, "config_path"):
+            self.all_configs = self.all_configs()
+
         with open(expected_fields_path, "r") as f:
             self.expected_fields = set(json.load(f))
+        self.table_name = list_url.split("/")[-1].split("_list.do")[0]
+        self.__dict__.update(kwargs)
 
     def setup_goal(self, page: Page) -> tuple[str, dict]:
         super().setup_goal(page=page)
@@ -501,36 +537,48 @@ class FilterListTask(ServiceNowListTask):
         config = self.fixed_config if self.fixed_config else self.random.choice(self.all_configs)
         self.filter_columns = config["filter_columns"]
         self.filter_values = config["filter_values"]
+        # Base filter configs do not have filter_operands, so we default to "is"
+        self.filter_operators = config.get("filter_operators", ["is" for _ in self.filter_columns])
         self.filter_kind = config["filter_kind"]
-        self.list_info = config["list_info"]
+        list_info = config.get("list_info")
+        if list_info is None:
+            list_info = {"columns": table_column_info(self.instance, self.table_name)}
+        self.list_info = list_info
         self.filter_len = len(self.filter_columns)
 
         # Generate goal
-        goal = (
-            f"Create a filter for the list to extract all entries where "
-            + f" {'and' if self.filter_kind == 'AND' else 'or'} ".join(
-                [
-                    f'"{self.list_info["columns"][col]["label"]}" is "{val}"'
-                    for col, val in zip(self.filter_columns, self.filter_values)
-                ]
-            )
-            + "."
-        )
+        goal = self.get_pretty_printed_description(goal=True)
         info = {}
 
         return goal, info
 
     def start(self, page: Page) -> None:
         super().start(page)
-
         self._wait_for_ready(page)
 
-        # Assert that required fields are visible (task feasibility check)
-        visible_list_info = self._extract_list_info(page)
-        visible_columns = set(visible_list_info["fields"].split(","))
-        assert (
-            set(self.filter_columns) <= visible_columns and visible_columns == self.expected_fields
-        ), f"Fields {self.filter_columns} are not all visible in the list. Re-run workarena-install to correct this."
+    def get_pretty_printed_description(self, goal=False) -> str:
+        """
+        Get the task info for this task when used in a private task; Used in L3 compositional tasks.
+        called by subclasses
+
+        args:
+        goal: bool
+            If True, return as the goal of the task (without the starting dash)
+        """
+        task_info = "" if goal else "- "
+        task_info += (
+            f"Create a filter for the list to extract all entries where:"
+            + f" {'and' if self.filter_kind == 'AND' else 'or'} ".join(
+                [
+                    f'\n    - "{self.list_info["columns"][col]["label"]}" {filter_operator} "{val}"'
+                    for col, filter_operator, val in zip(
+                        self.filter_columns, self.filter_operators, self.filter_values
+                    )
+                ]
+            )
+        )
+
+        return task_info
 
     def _generate_random_config(self, page: Page):
         self.setup(page=page)
@@ -563,7 +611,7 @@ class FilterListTask(ServiceNowListTask):
         # We do this by loading a single record at random and using its values
         # This is significantly faster than loading all records and then filtering
         offset = self.random.randint(
-            0, self.page.evaluate(f'{self.list_info["js_selector"]}.grandTotalRows')
+            0, page.evaluate(f'{self.list_info["js_selector"]}.grandTotalRows')
         )
         data = table_api_call(
             instance=self.instance,
@@ -652,7 +700,7 @@ class FilterListTask(ServiceNowListTask):
                     f'.filterToolbar .filerTableAction:text-is("{self.filter_kind}")'
                 ).click()
                 # TODO: Hack to solve bug where the filter condition has not yet appeared
-                self.page.wait_for_timeout(1000)
+                page.wait_for_timeout(1000)
 
             # Refresh since new rows are added at each iteration
             filter_rows = iframe.locator(".filter_row")
@@ -664,8 +712,14 @@ class FilterListTask(ServiceNowListTask):
             field_selector.select_option(self.filter_columns[i])
 
             # Select the right operator
-            logging.debug("Choosing operator =")
-            row.locator("select.condOperator").select_option("=")
+            operator = self.filter_operators[i]
+            operator_symbol = (
+                row.locator("select.condOperator")
+                .get_by_text(operator, exact=True)
+                .get_attribute("value")
+            )
+            logging.debug(f"Choosing operator {operator}")
+            row.locator("select.condOperator").select_option(operator_symbol)
 
             # Fill in the value
             logging.debug("Filling in value " + self.filter_values[i])
@@ -718,26 +772,19 @@ class FilterListTask(ServiceNowListTask):
                 },
             )
         self._wait_for_ready(page)
-        if self.filter_kind not in ["AND", "OR"]:
-            raise NotImplementedError("Only AND and OR filters are supported.")
-        # Excludes AND because that's the default and its sep is ^ which matches everywhere
-        query_sep = {"OR": "^NQ"}
 
-        # Retrieve list
+        # Retrieve the current query
         list_info = self._extract_list_info(page)
-
-        # Check if the list is filtered correctly
         current_query = list_info["query"]
 
+        # Replace "new query" statements with the standard OR separator
+        current_query = current_query.replace("^NQ", "^OR")
+
         # Validate query kind is ok
-        current_kind = None
-        for kind in query_sep:
-            if query_sep[kind] in current_query:
-                current_kind = kind
-                current_sep = query_sep[kind]
-                break
+        if "^OR" in current_query:
+            current_kind = "OR"
+            current_sep = "^OR"
         else:
-            # If no separator is found, then the query is just assumed to be AND (it's a single condition)
             current_kind = "AND"
             current_sep = "^"
 
@@ -760,24 +807,44 @@ class FilterListTask(ServiceNowListTask):
         # This is the tricky part because we need to expand the values to their display values
         # We also need to handle the case where the value is a reference
         current_values = [x.split("=")[1] for x in current_query]
-        for col, val in zip(current_columns, current_values):
-            col_info = self.list_info["columns"][col]
 
+        # Handle filtering across multiple rows
+        if len(set(current_columns)) < len(current_columns):
+            if len(set(current_columns)) != 1:
+                raise Exception("Filtering is only allowed across rows for the same column.")
+            # Filter multiple rows with a column
+            is_homogenous_filter = True
+        else:
+            # Current setting where we use multiple columns to filter
+            is_homogenous_filter = False
+        for index, (col, val) in enumerate(zip(current_columns, current_values)):
+            col_info = self.list_info["columns"][col]
             # Get the column type
             if col_info["type"] == "reference" and val != "":
                 # Get the reference table
                 ref_table = col_info["reference"]
                 ref_field = col_info["reference_attributes"]["display_field"]
-                # Get the reference display value
-                current_values[current_columns.index(col)] = table_api_call(
-                    instance=self.instance,
-                    table=ref_table,
-                    params={
-                        "sysparm_query": f"sys_id={val}",
-                        "sysparm_fields": ref_field,
-                        "sysparm_display_value": "all",
-                    },
-                )["result"][0][ref_field]["display_value"]
+                if is_homogenous_filter:
+                    current_values[index] = table_api_call(
+                        instance=self.instance,
+                        table=ref_table,
+                        params={
+                            "sysparm_query": f"sys_id={val}",
+                            "sysparm_fields": ref_field,
+                            "sysparm_display_value": "all",
+                        },
+                    )["result"][0][ref_field]["display_value"]
+                else:
+                    # Get the reference display value
+                    current_values[current_columns.index(col)] = table_api_call(
+                        instance=self.instance,
+                        table=ref_table,
+                        params={
+                            "sysparm_query": f"sys_id={val}",
+                            "sysparm_fields": ref_field,
+                            "sysparm_display_value": "all",
+                        },
+                    )["result"][0][ref_field]["display_value"]
 
             elif col_info["type"] == "choice":
                 # Get the choice display value
@@ -794,114 +861,409 @@ class FilterListTask(ServiceNowListTask):
         return 1, True, "Nice work, thank you!", {"message": "Correct filter."}
 
 
+class ExtractListInfoTask(ServiceNowListTask):
+    """
+    Extract information from some fields in a list. Works with any list.
+
+    Parameters:
+    -----------
+    instance: SNowInstance
+        The instance to use.
+    list_url: str
+        The relative URL of the list to filter.
+    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.
+    config_path:
+        The path to the JSON file containing all configurations for the task. Provided by subclasses
+    list_name: str
+        Name of the list to extract information from.
+    list_url: str
+        url of the list to extract information from.
+    unique_field_name: str
+        Name of the field used as unique in the list. This field is required in configs.
+    """
+
+    def __init__(
+        self,
+        seed: int = None,
+        instance=None,
+        fixed_config: dict = None,
+        configs: str = "",
+        list_name: str = "",
+        list_url: str = "",
+        unique_field_name: str = "",
+        **kwargs,
+    ) -> None:
+        super().__init__(
+            seed=seed, instance=instance, start_rel_url=list_url
+        )  # For these tasks, the start URL is defined in the setup method, as the URL depends on the configuration
+        self.fixed_config = fixed_config
+        self.config = None
+        self.all_configs = configs
+        self.list_name = list_name
+        self.table_name = ""
+        self.unique_field_name = unique_field_name
+        self.__dict__.update(kwargs)
+
+    def setup_goal(self, page: Page) -> tuple[str, dict]:
+        super().setup_goal(page=page)
+
+        # Get the task configuration
+        config = self.fixed_config if self.fixed_config else self.random.choice(self.all_configs)
+        self.fields = config["fields"]  # mapping between fields and their display names
+        self.printed_field_names = {
+            v: k for k, v in self.fields.items()
+        }  # mapping between fields and their system names
+        self.expected_values = config[
+            "expected_values"
+        ]  # mapping between fields and their expected values
+        # This is setup here because the start_url depends on the config
+        assert (
+            self.unique_field_name in self.fields.keys()
+        ), f"Unique field name {self.unique_field_name} not in fields."
+        assert all(
+            [self.unique_field_name in expected_value for expected_value in self.expected_values]
+        ), f"Unique field name {self.unique_field_name} not in expected values."
+
+        if not self.start_url or self.start_url == self.instance.snow_url:
+            self.start_rel_url = config["start_rel_url"]
+            self.start_url = self.instance.snow_url + self.start_rel_url
+        # table_name can be passed in the constructor or extracted from the start_rel_url, located in the config
+        if self.table_name is None:
+            self.table_name = self.start_rel_url.split("/")[-1].split("_list.do")[0]
+
+        goal = self.get_pretty_printed_description()
+        info = {}
+
+        return goal, info
+
+    def start(self, page: Page) -> None:
+        super().start(page)
+        # TODO: We should add a check to make sure the required columns are present in the list
+
+    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 and used as goal in L1 tasks.
+        called by subclasses
+        """
+        print_field_names = list(self.fields.values())
+        print_field_names.remove(
+            self.fields[self.unique_field_name]
+        )  # the unique fields are the keys in the dict
+        if len(print_field_names) > 1:
+            fields_str = (
+                '"' + '", "'.join(print_field_names[:-1]) + f'" and "{print_field_names[-1]}"'
+            )
+            printed_unique_field_name = self.fields[self.unique_field_name]
+            task_description = (
+                f"- Extract information of field(s) {fields_str} "
+                + f'from the "{self.list_name}" list. Return the result as a json where keys are the values of the "{printed_unique_field_name}" field and values are mappings between the fields and the extracted information. Please provide this information in the chat.'
+            )
+        else:
+            fields_str = print_field_names[0]
+            task_description = f'- Extract information of field "{fields_str}" from the "{self.list_name}" list. Please provide this information in the chat.'
+
+        return task_description
+
+    def _wait_for_ready(self, page: Page) -> bool:
+        """
+        Waits for the main iframe to be fully loaded; over-rides the parent method as the cheat
+        can be called on a filtered list on which there is no gsft_main.
+
+        Returns True if the gsft_main is present, False otherwise.
+        """
+        gsft_main_present = False
+        logging.debug(f"Waiting up to 3 seconds for gsft_main to be ready")
+        try:
+            page.wait_for_function(
+                "typeof window.gsft_main !== 'undefined' && window.gsft_main.WORKARENA_LOAD_COMPLETE",
+                timeout=3000,
+            )
+            logging.debug("Detected gsft_main ready")
+            gsft_main_present = True
+        except TimeoutError:
+            logging.debug(
+                "Timed out waiting for gsft_main to be ready; searching for GlideList API directly"
+            )
+            pass
+
+        logging.debug("Waiting for Glide list API to be available")
+        if gsft_main_present:
+            page.wait_for_function("window.gsft_main.GlideList2 !== undefined")
+        else:
+            page.wait_for_function("window.GlideList2 !== undefined")
+
+        logging.debug("Detected Glide list API ready")
+
+        return gsft_main_present
+
+    def cheat(self, page: Page, chat_messages: list[str]) -> None:
+        super().cheat(page=page, chat_messages=chat_messages)
+        right_url = check_url_suffix_match(page, expected_url=self.start_url, task=self)
+        if not right_url:
+            return
+        gft_main_present = self._wait_for_ready(page)
+        if gft_main_present:
+            main_element = page.wait_for_selector("iframe#gsft_main").content_frame()
+        else:
+            main_element = page
+
+        main_element.wait_for_selector(
+            f"#hdr_{self.table_name}"
+        )  # Selector for the name of the columns
+        # system name mapped to their order in the table
+        all_column_elements = main_element.query_selector_all(f"#hdr_{self.table_name} th")
+        required_fields_order = {}
+        for i, element in enumerate(all_column_elements):
+            if element.get_attribute("name") in self.fields:
+                required_fields_order[element.get_attribute("name")] = i
+
+        # Lines of the table
+        table_lines = main_element.query_selector_all(
+            f".list2_body [record_class={self.table_name}]"
+        )
+
+        # will hold the values to extract
+        table_values = {}
+
+        # Extract the values of the required fields
+        for line_element in table_lines:
+            line_fields = line_element.query_selector_all("td")
+            line_values = {}
+            for field, order in required_fields_order.items():
+                printed_field_name = self.fields[field]
+                line_values[printed_field_name] = line_fields[order].inner_text()
+            printed_unique_value_name = self.fields[self.unique_field_name]
+            unique_field_value = line_values[printed_unique_value_name]
+            line_values.pop(printed_unique_value_name)
+            table_values[unique_field_value] = line_values
+
+        # Add the "extracted" answer to the chat messages
+        if len(self.fields) > 2:
+            chat_messages.append({"role": "assistant", "message": json.dumps(table_values)})
+        # In this case, we expect only one field to be extracted
+        else:
+            expected_field = list(self.fields.keys() - {self.unique_field_name})[0]
+            pretty_field_name = self.fields[expected_field]
+            # Here we assume that unique_field_value is unique in the table_values
+            chat_messages.append(
+                {
+                    "role": "assistant",
+                    "message": str(table_values[unique_field_value][pretty_field_name]),
+                }
+            )
+
+    def validate(
+        self, page: playwright.sync_api.Page, chat_messages: list[str]
+    ) -> Tuple[float, bool, str, dict]:
+        """
+        Validate the solution
+
+        Note: current implementation is limited to AND and OR filters (single type per filter) with equality operators
+
+        """
+        if (
+            len(chat_messages) == 0
+            or chat_messages[-1]["role"] != "assistant"
+            or not chat_messages[-1]["message"]
+        ):
+            return 0, False, "", {"message": "No extracted values found."}
+
+        # When 2 or more fields (unique field is always present so at least 2 fields are present), we expect a dict
+        # Otherwise, we only look for the presence of the expected value in the message sent by the agent
+        if len(self.fields) > 2:
+            answer = json.loads(chat_messages[-1]["message"])
+            for expected_line in self.expected_values:
+                # Check if the line is in the visible lines
+                if expected_line[self.unique_field_name] not in answer:
+                    return (
+                        0,
+                        False,
+                        "",
+                        {
+                            "message": f"Value {expected_line[self.unique_field_name]} for unique field {self.unique_field_name} not found in the list."
+                        },
+                    )
+                # Check if the values are correct
+                unique_value = expected_line[self.unique_field_name]
+                # This checks all fields inside the dict for the unique value
+                for field, value in expected_line.items():
+                    # The unique field's presence is implicitly validated by the above check
+                    if field == self.unique_field_name:
+                        continue
+                    printed_field_name = self.fields[field]
+                    if answer[unique_value][printed_field_name] != value:
+                        return 0, False, "", {"message": "Incorrect value."}
+        # In this case, we expect only one field to be extracted
+        else:
+            # get the field that is not the unique field
+            field = list(self.fields.keys() - {self.unique_field_name})[0]
+            expected_value = str(self.expected_values[0][field])
+            if expected_value not in chat_messages[-1]["message"]:
+                return 0, False, "", {"message": "Incorrect value."}
+
+        return (
+            1,
+            True,
+            "Nice work, thank you!",
+            {"message": "Correct information extracted."},
+        )
+
+
 class FilterAssetListTask(FilterListTask):
+    config_path = FILTER_ASSET_LIST_CONFIG_PATH
+
     def __init__(
         self,
-        seed: int,
+        seed: int = None,
         instance=None,
         fixed_config: dict = None,
+        **kwargs,
     ) -> None:
         super().__init__(
             seed=seed,
             instance=instance,
             list_url=LISTS["alm_asset"]["url"],
             fixed_config=fixed_config,
-            config_path=FILTER_ASSET_LIST_CONFIG_PATH,
             expected_fields_path=EXPECTED_ASSET_LIST_COLUMNS_PATH,
+            **kwargs,
         )
 
 
 class FilterChangeRequestListTask(FilterListTask):
+    config_path = FILTER_CHANGE_REQUEST_LIST_CONFIG_PATH
+
     def __init__(
         self,
-        seed: int,
+        seed: int = None,
         instance=None,
         fixed_config: dict = None,
+        **kwargs,
     ) -> None:
         super().__init__(
             seed=seed,
             instance=instance,
             list_url=LISTS["change_request"]["url"],
             fixed_config=fixed_config,
-            config_path=FILTER_CHANGE_REQUEST_LIST_CONFIG_PATH,
             expected_fields_path=EXPECTED_CHANGE_REQUEST_COLUMNS_PATH,
+            **kwargs,
         )
 
 
 class FilterHardwareListTask(FilterListTask):
+    config_path = FILTER_HARDWARE_LIST_CONFIG_PATH
+
     def __init__(
         self,
-        seed: int,
+        seed: int = None,
         instance=None,
         fixed_config: dict = None,
+        **kwargs,
     ) -> None:
         super().__init__(
             seed=seed,
             instance=instance,
             list_url=LISTS["alm_hardware"]["url"],
             fixed_config=fixed_config,
-            config_path=FILTER_HARDWARE_LIST_CONFIG_PATH,
             expected_fields_path=EXPECTED_HARDWARE_COLUMNS_PATH,
+            **kwargs,
         )
 
 
 class FilterIncidentListTask(FilterListTask):
+    config_path = FILTER_INCIDENT_LIST_CONFIG_PATH
+
     def __init__(
         self,
-        seed: int,
+        seed: int = None,
         instance=None,
         fixed_config: dict = None,
+        **kwargs,
     ) -> None:
         super().__init__(
             seed=seed,
             instance=instance,
             list_url=LISTS["incident"]["url"],
             fixed_config=fixed_config,
-            config_path=FILTER_INCIDENT_LIST_CONFIG_PATH,
             expected_fields_path=EXPECTED_INCIDENT_COLUMNS_PATH,
+            **kwargs,
         )
 
 
+class FilterProblemListForWorkLoadBalancingTask(FilterListTask, CompositionalBuildingBlockTask):
+    def __init__(
+        self,
+        seed: int = None,
+        instance=None,
+        fixed_config: dict = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(
+            seed=seed,
+            instance=instance,
+            list_url="/now/nav/ui/classic/params/target/problem_list.do",
+            fixed_config=fixed_config,
+            expected_fields_path=EXPECTED_PROBLEM_COLUMNS_PATH,
+            **kwargs,
+        )
+
+    def get_pretty_printed_description(self, goal=False) -> str:
+        """Override the parent method to provide a more detailed description of the task"""
+
+        return self.goal
+
+
 class FilterServiceCatalogItemListTask(FilterListTask):
+    config_path = FILTER_SERVICE_CATALOG_ITEM_LIST_CONFIG_PATH
+
     def __init__(
         self,
-        seed: int,
+        seed: int = None,
         instance=None,
         fixed_config: dict = None,
+        **kwargs,
     ) -> None:
         super().__init__(
             seed=seed,
             instance=instance,
             list_url=LISTS["sc_cat_item"]["url"],
             fixed_config=fixed_config,
-            config_path=FILTER_SERVICE_CATALOG_ITEM_LIST_CONFIG_PATH,
             expected_fields_path=EXPECTED_SERVICE_CATALOG_COLUMNS_PATH,
+            **kwargs,
         )
 
 
 class FilterUserListTask(FilterListTask):
+    config_path = FILTER_USER_LIST_CONFIG_PATH
+
     def __init__(
         self,
-        seed: int,
+        seed: int = None,
         instance=None,
         fixed_config: dict = None,
+        **kwargs,
     ) -> None:
         super().__init__(
             seed=seed,
             instance=instance,
             list_url=LISTS["sys_user"]["url"],
             fixed_config=fixed_config,
-            config_path=FILTER_USER_LIST_CONFIG_PATH,
             expected_fields_path=EXPECTED_USER_COLUMNS_PATH,
+            **kwargs,
         )
 
 
 class SortAssetListTask(SortListTask):
+    config_path = SORT_ASSET_LIST_CONFIG_PATH
+
     def __init__(
         self,
-        seed: int,
+        seed: int = None,
         instance=None,
         fixed_config: dict = None,
+        **kwargs,
     ) -> None:
         super().__init__(
             seed=seed,
@@ -909,17 +1271,20 @@ class SortAssetListTask(SortListTask):
             list_url=LISTS["alm_asset"]["url"],
             forbidden_fields=LISTS["alm_asset"]["forbidden_fields"],
             fixed_config=fixed_config,
-            config_path=SORT_ASSET_LIST_CONFIG_PATH,
             expected_fields_path=EXPECTED_ASSET_LIST_COLUMNS_PATH,
+            **kwargs,
         )
 
 
 class SortChangeRequestListTask(SortListTask):
+    config_path = SORT_CHANGE_REQUEST_LIST_CONFIG_PATH
+
     def __init__(
         self,
-        seed: int,
+        seed: int = None,
         instance=None,
         fixed_config: dict = None,
+        **kwargs,
     ) -> None:
         super().__init__(
             seed=seed,
@@ -927,17 +1292,20 @@ class SortChangeRequestListTask(SortListTask):
             list_url=LISTS["change_request"]["url"],
             forbidden_fields=LISTS["change_request"]["forbidden_fields"],
             fixed_config=fixed_config,
-            config_path=SORT_CHANGE_REQUEST_LIST_CONFIG_PATH,
             expected_fields_path=EXPECTED_CHANGE_REQUEST_COLUMNS_PATH,
+            **kwargs,
         )
 
 
 class SortHardwareListTask(SortListTask):
+    config_path = SORT_HARDWARE_LIST_CONFIG_PATH
+
     def __init__(
         self,
-        seed: int,
+        seed: int = None,
         instance=None,
         fixed_config: dict = None,
+        **kwargs,
     ) -> None:
         super().__init__(
             seed=seed,
@@ -945,17 +1313,20 @@ class SortHardwareListTask(SortListTask):
             list_url=LISTS["alm_hardware"]["url"],
             forbidden_fields=LISTS["alm_hardware"]["forbidden_fields"],
             fixed_config=fixed_config,
-            config_path=SORT_HARDWARE_LIST_CONFIG_PATH,
             expected_fields_path=EXPECTED_HARDWARE_COLUMNS_PATH,
+            **kwargs,
         )
 
 
 class SortIncidentListTask(SortListTask):
+    config_path = SORT_INCIDENT_LIST_CONFIG_PATH
+
     def __init__(
         self,
-        seed: int,
+        seed: int = None,
         instance=None,
         fixed_config: dict = None,
+        **kwargs,
     ) -> None:
         super().__init__(
             seed=seed,
@@ -963,17 +1334,20 @@ class SortIncidentListTask(SortListTask):
             list_url=LISTS["incident"]["url"],
             forbidden_fields=LISTS["incident"]["forbidden_fields"],
             fixed_config=fixed_config,
-            config_path=SORT_INCIDENT_LIST_CONFIG_PATH,
             expected_fields_path=EXPECTED_INCIDENT_COLUMNS_PATH,
+            **kwargs,
         )
 
 
 class SortServiceCatalogItemListTask(SortListTask):
+    config_path = SORT_SERVICE_CATALOG_ITEM_LIST_CONFIG_PATH
+
     def __init__(
         self,
-        seed: int,
+        seed: int = None,
         instance=None,
         fixed_config: dict = None,
+        **kwargs,
     ) -> None:
         super().__init__(
             seed=seed,
@@ -981,17 +1355,20 @@ class SortServiceCatalogItemListTask(SortListTask):
             list_url=LISTS["sc_cat_item"]["url"],
             forbidden_fields=LISTS["sc_cat_item"]["forbidden_fields"],
             fixed_config=fixed_config,
-            config_path=SORT_SERVICE_CATALOG_ITEM_LIST_CONFIG_PATH,
             expected_fields_path=EXPECTED_SERVICE_CATALOG_COLUMNS_PATH,
+            **kwargs,
         )
 
 
 class SortUserListTask(SortListTask):
+    config_path = SORT_USER_LIST_CONFIG_PATH
+
     def __init__(
         self,
-        seed: int,
+        seed: int = None,
         instance=None,
         fixed_config: dict = None,
+        **kwargs,
     ) -> None:
         super().__init__(
             seed=seed,
@@ -999,12 +1376,52 @@ class SortUserListTask(SortListTask):
             list_url=LISTS["sys_user"]["url"],
             forbidden_fields=LISTS["sys_user"]["forbidden_fields"],
             fixed_config=fixed_config,
-            config_path=SORT_USER_LIST_CONFIG_PATH,
             expected_fields_path=EXPECTED_USER_COLUMNS_PATH,
+            **kwargs,
+        )
+
+
+class ExtractUserListInfoTask(ExtractListInfoTask, CompositionalBuildingBlockTask):
+    def __init__(
+        self,
+        seed: int = None,
+        instance=None,
+        fixed_config: dict = None,
+        config_path=EXTRACT_USER_LIST_INFO_CONFIG,
+        list_name="User",
+        unique_field_name="user_name",
+        **kwargs,
+    ) -> None:
+        super().__init__(
+            seed=seed,
+            instance=instance,
+            fixed_config=fixed_config,
+            config_path=config_path,
+            list_name=list_name,
+            unique_field_name=unique_field_name,
+            table_name="sys_user",
+            **kwargs,
         )
 
 
 # Register all tasks
-__TASKS__ = [
-    value for name, value in locals().items() if re.compile(r"^Filter\w+ListTask$").match(name)
-] + [value for name, value in locals().items() if re.compile(r"^Sort\w+ListTask$").match(name)]
+__TASKS__ = (
+    [
+        value
+        for name, value in locals().items()
+        if re.compile(r"^Filter\w+ListTask$").match(name)
+        and not issubclass(value, CompositionalBuildingBlockTask)
+    ]
+    + [
+        value
+        for name, value in locals().items()
+        if re.compile(r"^Sort\w+ListTask$").match(name)
+        and not issubclass(value, CompositionalBuildingBlockTask)
+    ]
+    + [
+        value
+        for name, value in locals().items()
+        if re.compile(r"^Extract\w+ListInfoTask$").match(name)
+        and not issubclass(value, CompositionalBuildingBlockTask)
+    ]
+)