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

browsergym/workarena/tasks/knowledge.py

@@ -5,15 +5,20 @@ Tasks related to knowledge bases.
 
 import json
 import logging
+import re
 
 from playwright.sync_api import Page
+from typing import Tuple
 from urllib import parse
 
 from .base import AbstractServiceNowTask
-from ..config import KB_NAME, KB_FILEPATH, KB_CONFIG_PATH, SNOW_BROWSER_TIMEOUT
+from .comp_building_block import CompositionalBuildingBlockTask
+from .utils.utils import check_url_suffix_match
+
+from ..api.utils import table_api_call
+from ..config import KB_FILEPATH, KB_CONFIG_PATH, KB_NAME, SNOW_BROWSER_TIMEOUT
 from ..install import check_knowledge_base
 from ..instance import SNowInstance
-from .utils.utils import check_url_suffix_match
 
 
 class KnowledgeBaseSearchTask(AbstractServiceNowTask):
@@ -32,7 +37,33 @@ class KnowledgeBaseSearchTask(AbstractServiceNowTask):
 
     """
 
-    def __init__(self, seed: int, instance=None, fixed_config: dict = None) -> None:
+    def __init__(
+        self,
+        instance=None,
+        fixed_config: dict = None,
+        is_correct: bool = True,
+        is_only_navigating: bool = False,
+        search_by_title: bool = False,
+        seed: int = None,
+        **kwargs,
+    ) -> None:
+        """
+        Parameters:
+        -----------
+        instance: SNowInstance
+            The ServiceNow instance to run the task on.
+        fixed_config:
+            A fixed configuration for the task, if required.
+        is_correct: bool
+            Used for the compositional task.
+            If false, the answer is highlighted in 'red' instead of 'yellow' when using cheat.
+        is_only_navigating: bool
+            Used for the compositional task.
+            If we only are navigating and not searching, change the goal for the agent.
+        search_by_title: bool
+            Used for the compositional task.
+            If true, clicks on the article title using the article name, else opens the first article.
+        """
         super().__init__(
             seed=seed,
             instance=instance,
@@ -42,9 +73,18 @@ class KnowledgeBaseSearchTask(AbstractServiceNowTask):
         # Load the knowledge base and check its integrity
         with open(KB_FILEPATH, "r") as f:
             self.kb_entries = json.load(f)
-        _, requires_install, requires_delete = check_knowledge_base(
-            self.instance, kb_data=self.kb_entries, kb_name=KB_NAME
-        )
+        if hasattr(self, "_base_initial_instance"):
+            _, requires_install, requires_delete = check_knowledge_base(
+                self._base_initial_instance,  # if user does not have permission to view the kb then this breaks
+                kb_name=KB_NAME,
+                kb_data=self.kb_entries,  # Need admin permissions to check
+            )
+        else:
+            _, requires_install, requires_delete = check_knowledge_base(
+                SNowInstance(),  # instance would be the non-admin instance here and this might break in case user does not have required permissions
+                kb_name=KB_NAME,
+                kb_data=self.kb_entries,  # Need admin permissions to check
+            )
         with open(KB_CONFIG_PATH, "r") as f:
             self.all_configs = json.load(f)
         if any([requires_install, requires_delete]):
@@ -53,6 +93,14 @@ class KnowledgeBaseSearchTask(AbstractServiceNowTask):
                 "See README for setup instructions."
             )
         self.fixed_config = fixed_config
+        self.config = None
+
+        # Attributes for compositional task
+        self.is_correct = is_correct
+        self.is_only_navigating = is_only_navigating
+        self.search_by_title = search_by_title
+
+        self.__dict__.update(kwargs)
 
     def _wait_for_ready(self, page: Page) -> None:
         """
@@ -92,13 +140,33 @@ class KnowledgeBaseSearchTask(AbstractServiceNowTask):
         self.answer = config["value"]
         self.alternative_answers = config["alternative_answers"]
         self.question = config["question"]
+        if self.search_by_title:
+            self.kb_article_title = config["kb_article_title"]
 
         # Generate goal
-        goal = f'Answer the following question using the knowledge base: "{self.question}"'
+        if self.is_only_navigating:
+            goal = f'Navigate to a relevant article in the knowledge base by searching for: "{self.item}" and open the article: "{self.kb_article_title}"'
+        else:
+            goal = f'Answer the following question using the knowledge base: "{self.question}"'
         info = {}
 
         return goal, info
 
+    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
+        """
+        class_name = self.__class__.__name__
+        class_name = class_name.replace("Task", "")
+        # Split the words
+        words = re.findall(r"[A-Z][^A-Z]*", class_name)
+        class_name_formatted = " ".join(words)
+
+        task_info = f"- {class_name_formatted}: {self.item} \n"
+
+        return task_info
+
     def cheat(self, page: Page, chat_messages: list[str]) -> None:
         super().cheat(page=page, chat_messages=chat_messages)
         self._wait_for_ready(page)
@@ -112,7 +180,10 @@ class KnowledgeBaseSearchTask(AbstractServiceNowTask):
 
         # Click on the article
         with page.expect_navigation():
-            iframe.locator("a.kb-title").first.click()
+            if self.search_by_title:
+                iframe.locator(f'a.kb-title:has-text("{self.kb_article_title}")').click()
+            else:
+                iframe.locator("a.kb-title").first.click()
 
         # Color the query and answer (this is just for visualization, it changes nothing to the validation)
         paragraphs = iframe.locator("p")
@@ -125,10 +196,16 @@ class KnowledgeBaseSearchTask(AbstractServiceNowTask):
                     self.item,
                     f'<span style="background-color: cyan;">{self.item}</span>',
                 )
-                inner_html = inner_html.replace(
-                    str(self.answer),
-                    f'<span style="background-color: yellow;">{self.answer}</span>',
-                )
+                if self.is_correct:
+                    inner_html = inner_html.replace(
+                        str(self.answer),
+                        f'<span style="background-color: yellow;">{self.answer}</span>',
+                    )
+                else:
+                    inner_html = inner_html.replace(
+                        str(self.answer),
+                        f'<span style="background-color: pink;">{self.answer}</span>',
+                    )
                 paragraph.evaluate(f"element => element.innerHTML = `{inner_html}`")
                 break
 
@@ -137,16 +214,6 @@ class KnowledgeBaseSearchTask(AbstractServiceNowTask):
         chat_messages.append({"role": "assistant", "message": str(self.answer)})
 
     def validate(self, page: Page, chat_messages: list[str]) -> tuple[float, bool, str, dict]:
-        right_url = check_url_suffix_match(page, expected_url="target/kb", task=self)
-        if not right_url:
-            return (
-                0,
-                False,
-                "",
-                {
-                    "message": f"The page is not in the right URL to validate task {self.__class__.__name__}."
-                },
-            )
         if chat_messages and chat_messages[-1]["role"] == "assistant":
             answer = chat_messages[-1]["message"]
         else:
@@ -160,9 +227,133 @@ class KnowledgeBaseSearchTask(AbstractServiceNowTask):
         accepted_answers = [a.lower() for a in [self.answer] + self.alternative_answers]
         answer = answer.lower()
         if any(a in answer for a in accepted_answers):
-            return 1, True, "That is correct, thank you!", {"message": "Correct answer."}
+            return (
+                1,
+                True,
+                "That is correct, thank you!",
+                {"message": "Correct answer."},
+            )
         else:
-            return 0, False, "", {"message": "Incorrect answer provided by the assistant."}
+            return (
+                0,
+                False,
+                "",
+                {"message": "Incorrect answer provided by the assistant."},
+            )
+
+
+class AddCommentToKnowledgeArticleTask(AbstractServiceNowTask, CompositionalBuildingBlockTask):
+    """
+    Task to add a comment to a knowledge base article. Only used as a part of the compositional task for edit knowledge base
+    Parameters:
+    -----------
+    instance: SNowInstance
+        The instance on which to create the record.
+    fixed_config: dict
+        Configuration to use for the task.
+    """
+
+    def __init__(
+        self, seed: int = None, instance=None, fixed_config: dict = None, **kwargs
+    ) -> None:
+        super().__init__(
+            seed=seed,
+            instance=instance,
+            start_rel_url="/now/nav/ui/classic/params/target/kb?id=kb_home",
+            user_roles=[],
+        )
+        self.fixed_config = fixed_config
+        if self.fixed_config is None:
+            raise Exception("Please provide a config for the add comment task.")
+        self.__dict__.update(kwargs)
+
+    def setup_goal(self, page: Page) -> tuple[str, dict]:
+        super().setup_goal(page=page)
+        config = self.fixed_config
+
+        if "kb_article_title" not in config.keys():
+            raise Exception("Need title in config file...")
+        self.article_name = config["kb_article_title"]
+        adhoc_kb_response = table_api_call(
+            instance=self.instance,  # admin permissions to contribute to the KB
+            table="kb_knowledge",
+            method="GET",
+            params={
+                "sysparm_query": f"short_description={self.article_name}",
+            },
+        )["result"]
+        if len(adhoc_kb_response) != 1:
+            raise Exception("Required article not found, please fix config...")
+
+        self.kb_article_sys_id = adhoc_kb_response[0]["sys_id"]
+        self.comment = config["comment"]
+
+        goal = f'Add the following comment to the knowledge base: "{self.comment}"'
+        info = {}
+
+        return goal, info
+
+    def _wait_for_ready(self, page: Page) -> None:
+        """
+        Checks that the main iframe is fully loaded
+
+        """
+        # TODO: We don't use the flag-based method used in other tasks
+        #       because gsft_main doesn't have the event we register
+        #       on this page. Not sure why.
+        logging.debug(f"Waiting for page to be fully loaded")
+        page.wait_for_load_state("networkidle")
+        page.wait_for_selector('iframe[name="gsft_main"]')
+        logging.debug(f"Detected page ready")
+
+        # Get main iframe
+        # XXX: We use a loop because sometimes the iframe evaluates to None
+        #      even though we wait for it to be ready. This seems like a
+        #      playwright bug.
+        timeout = SNOW_BROWSER_TIMEOUT
+        while timeout > 0:
+            iframe = page.frame(name="gsft_main")
+            if iframe:
+                break
+            page.wait_for_timeout(100)
+            timeout -= 100
+        else:
+            raise TimeoutError(
+                f"Timed out waiting for iframe to be ready in {self.instance.snow_url}"
+            )
+
+    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
+        """
+        class_name = self.__class__.__name__
+        class_name = class_name.replace("Task", "")
+        # Split the words
+        words = re.findall(r"[A-Z][^A-Z]*", class_name)
+        class_name_formatted = " ".join(words)
+
+        task_info = f"- {class_name_formatted}: Add the comment '{self.comment}' for the article with title {self.article_name} \n"
+
+        return task_info
+
+    def cheat(self, page: Page, chat_messages: list[str]) -> None:
+        super().cheat(page=page, chat_messages=chat_messages)
+
+        # Check if we need to do something else, gsft_main is not loading, it seems to load when navigating from the search, so might need for compositional tasks
+        self._wait_for_ready(page)
+        frame = page.frame("gsft_main")
+        frame.locator("button.comment-text").click()
+        frame.frame_locator('iframe[title="Rich Text Area"]').locator("html").click()
+        frame.frame_locator('iframe[title="Rich Text Area"]').get_by_label("Comments").fill(
+            self.comment
+        )
+        frame.get_by_role("button", name="Submit").click()
+
+    def validate(self, page: Page, chat_messages: list[str]) -> Tuple[float, bool, str, dict]:
+        return super().validate(page, chat_messages)
 
 
-__TASKS__ = [KnowledgeBaseSearchTask]
+__TASKS__ = [
+    KnowledgeBaseSearchTask,
+]