browsergym-workarena 0.4.3__py3-none-any.whl → 0.5.0__py3-none-any.whl

browsergym/workarena/install.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+import argparse
 import html
 import json
 import logging
@@ -10,6 +13,7 @@ from tenacity import retry, stop_after_attempt, retry_if_exception_type
 from requests import HTTPError
 from time import sleep
 
+from .api.system_properties import get_sys_property, set_sys_property
 from .api.ui_themes import get_workarena_theme_variants
 from .api.user import create_user
 from .api.utils import table_api_call, table_column_info
@@ -38,7 +42,7 @@ from .config import (
     EXPECTED_USER_FORM_FIELDS_PATH,
     # Patch flag for reports
     REPORT_PATCH_FLAG,
-    REPORT_DATE_FILTER,
+    REPORT_FILTER_PROPERTY,
     # Supported ServiceNow releases
     SNOW_SUPPORTED_RELEASES,
     # For workflows setup
@@ -47,55 +51,52 @@ from .config import (
     UI_THEMES_UPDATE_SET,
 )
 from .api.user import set_user_preference
-from .instance import SNowInstance
+from .instance import SNowInstance as _BaseSNowInstance
 from .utils import url_login
 
 
-def _set_sys_property(property_name: str, value: str):
-    """
-    Set a sys_property in the instance.
+_CLI_INSTANCE_URL: str | None = None
+_CLI_INSTANCE_PASSWORD: str | None = None
+
 
+def SNowInstance(snow_credentials: tuple[str, str] | None = None):
     """
-    instance = SNowInstance()
+    Wrapper around the standard SNowInstance that uses CLI-provided instance URL and password if none are provided.
+    """
+    if not _CLI_INSTANCE_URL:
+        raise RuntimeError("Installer requires --instance-url to create a SNowInstance.")
 
-    property = table_api_call(
-        instance=instance,
-        table="sys_properties",
-        params={"sysparm_query": f"name={property_name}", "sysparm_fields": "sys_id"},
-    )["result"]
+    resolved_creds = snow_credentials
 
-    if not property:
-        property_sysid = ""
-        method = "POST"
-    else:
-        property_sysid = "/" + property[0]["sys_id"]
-        method = "PUT"
+    if resolved_creds is None:
+        if not _CLI_INSTANCE_PASSWORD:
+            raise RuntimeError(
+                "Installer requires --instance-password (or explicit credentials) to create a SNowInstance."
+            )
+        resolved_creds = ("admin", _CLI_INSTANCE_PASSWORD)
 
-    property = table_api_call(
-        instance=instance,
-        table=f"sys_properties{property_sysid}",
-        method=method,
-        json={"name": property_name, "value": value},
+    return _BaseSNowInstance(
+        snow_url=_CLI_INSTANCE_URL,
+        snow_credentials=resolved_creds,
     )
 
-    # Verify that the property was updated
-    assert property["result"]["value"] == value, f"Error setting {property_name}."
-
 
-def _get_sys_property(property_name: str) -> str:
+def _is_dev_portal_instance() -> bool:
     """
-    Get a sys_property from the instance.
+    Check if the instance is a ServiceNow Developer Portal instance.
+
+    Returns:
+    --------
+    bool: True if the instance is a developer portal instance, False otherwise.
 
     """
     instance = SNowInstance()
-
-    property_value = table_api_call(
-        instance=instance,
-        table="sys_properties",
-        params={"sysparm_query": f"name={property_name}", "sysparm_fields": "value"},
-    )["result"][0]["value"]
-
-    return property_value
+    # Check if the instance url has the for devXXXXXX.service-now.com format (where X is a digit)
+    if re.match(r"^https?://dev\d{6}\.service-now\.com", instance.snow_url):
+        logging.info("Detected a developer portal instance...")
+        return True
+    logging.info("Detected an internal instance...")
+    return False
 
 
 def _install_update_set(path: str, name: str):
@@ -797,7 +798,9 @@ def enable_url_login():
     Configure the instance to allow login via URL.
 
     """
-    _set_sys_property(property_name="glide.security.restrict.get.login", value="false")
+    set_sys_property(
+        instance=SNowInstance(), property_name="glide.security.restrict.get.login", value="false"
+    )
     logging.info("URL login enabled.")
 
 
@@ -808,7 +811,28 @@ def disable_password_policies():
     Notes: this is required to allow the creation of users with weak passwords.
 
     """
-    _set_sys_property(property_name="glide.security.password.policy.enabled", value="false")
+    set_sys_property(
+        instance=SNowInstance(),
+        property_name="glide.security.password.policy.enabled",
+        value="false",
+    )
+    set_sys_property(
+        instance=SNowInstance(), property_name="glide.apply.password_policy.on_login", value="false"
+    )
+    # Exception handling since this property is sometimes read-only on some instances
+    try:
+        set_sys_property(
+            instance=SNowInstance(),
+            property_name="glide.authenticate.api.user.reset_password.mandatory",
+            value="false",
+        )
+    except Exception:
+        logging.warning(
+            "Warning: Failed to set sys property "
+            "'glide.authenticate.api.user.reset_password.mandatory'. Continuing.",
+            exc_info=True,
+        )
+
     logging.info("Password policies disabled.")
 
 
@@ -817,8 +841,14 @@ def disable_guided_tours():
     Hide guided tour popups
 
     """
-    _set_sys_property(property_name="com.snc.guided_tours.sp.enable", value="false")
-    _set_sys_property(property_name="com.snc.guided_tours.standard_ui.enable", value="false")
+    set_sys_property(
+        instance=SNowInstance(), property_name="com.snc.guided_tours.sp.enable", value="false"
+    )
+    set_sys_property(
+        instance=SNowInstance(),
+        property_name="com.snc.guided_tours.standard_ui.enable",
+        value="false",
+    )
     logging.info("Guided tours disabled.")
 
 
@@ -836,7 +866,9 @@ def disable_analytics_popups():
     Disable analytics popups (needs to be done through UI since Vancouver release)
 
     """
-    _set_sys_property(property_name="glide.analytics.enabled", value="false")
+    set_sys_property(
+        instance=SNowInstance(), property_name="glide.analytics.enabled", value="false"
+    )
     logging.info("Analytics popups disabled.")
 
 
@@ -850,7 +882,8 @@ def setup_ui_themes():
     check_ui_themes_installed()
 
     logging.info("Setting default UI theme")
-    _set_sys_property(
+    set_sys_property(
+        instance=SNowInstance(),
         property_name="glide.ui.polaris.theme.custom",
         value=get_workarena_theme_variants(SNowInstance())[0]["theme.sys_id"],
     )
@@ -894,7 +927,9 @@ def check_ui_themes_installed():
 
 def set_home_page():
     logging.info("Setting default home page")
-    _set_sys_property(property_name="glide.login.home", value="/now/nav/ui/home")
+    set_sys_property(
+        instance=SNowInstance(), property_name="glide.login.home", value="/now/nav/ui/home"
+    )
 
 
 def wipe_system_admin_preferences():
@@ -918,9 +953,9 @@ def wipe_system_admin_preferences():
         )
 
 
-def is_report_filter_using_time(filter):
+def is_report_filter_using_relative_time(filter):
     """
-    Heuristic to check if a report is filtering based on time
+    Heuristic to check if a report is filtering based on relative time
 
     This aims to detect the use of functions like "gs.endOfToday()". To avoid hardcoding all of them,
     we simply check for the use of keywords. Our filter is definitely too wide, but that's ok.
@@ -938,6 +973,32 @@ def patch_report_filters():
     logging.info("Patching reports with date filter...")
 
     instance = SNowInstance()
+    filter_config = instance.report_filter_config
+
+    # If the report date filter is already set, we use the existing values (would be the case on reinstall)
+    if not filter_config:
+        # Set the report date filter to current date as YYYY-MM-DD and time filter to current time as HH:MM:SS
+        now = datetime.now()
+        report_date_filter = now.strftime("%Y-%m-%d")
+        report_time_filter = now.strftime("%H:%M:%S")
+        # ... save the filter config
+        logging.info(
+            f"Setting report date filter to {report_date_filter} and time filter to {report_time_filter} via {REPORT_FILTER_PROPERTY}"
+        )
+        set_sys_property(
+            instance=instance,
+            property_name=REPORT_FILTER_PROPERTY,
+            value=json.dumps(
+                {"report_date_filter": report_date_filter, "report_time_filter": report_time_filter}
+            ),
+        )
+    else:
+        # Use the existing configuration
+        logging.info(
+            f"Using existing report date filter {filter_config['report_date_filter']} and time filter {filter_config['report_time_filter']}"
+        )
+        report_date_filter = filter_config["report_date_filter"]
+        report_time_filter = filter_config["report_time_filter"]
 
     # Get all reports that are not already patched
     reports = table_api_call(
@@ -959,27 +1020,31 @@ def patch_report_filters():
                 logging.info(f"Discarding report {report['title']} {report['sys_id']}...")
                 raise NotImplementedError()  # Mark for deletion
 
-            if not is_report_filter_using_time(report["filter"]):
+            if not is_report_filter_using_relative_time(report["filter"]):
                 # That's a report we want to keep (use date cutoff filter)
-                filter_date = REPORT_DATE_FILTER
+                filter_date = report_date_filter
+                filter_time = report_time_filter
                 logging.info(
                     f"Keeping report {report['title']} {report['sys_id']} (columns: {sys_created_on_cols})..."
                 )
             else:
-                # XXX: We do not support reports with filters that rely on time (e.g., last 10 days) because
+                # XXX: We do not support reports with filters that rely on relative time (e.g., last 10 days) because
                 #      there are not stable. In this case, we don't delete them but add a filter to make
                 #      them empty. They will be shown as "No data available".
                 logging.info(
                     f"Disabling report {report['title']} {report['sys_id']} because it uses time filters..."
                 )
                 filter_date = "1900-01-01"
+                filter_time = "00:00:00"
 
+            # Format the filter
             filter = "".join(
                 [
-                    f"^{col}<javascript:gs.dateGenerate('{filter_date}','00:00:00')"
+                    f"^{col}<javascript:gs.dateGenerate('{filter_date}','{filter_time}')"
                     for col in sys_created_on_cols
                 ]
             ) + ("^" if len(report["filter"]) > 0 and not report["filter"].startswith("^") else "")
+            # Patch the report with the new filter
             table_api_call(
                 instance=instance,
                 table=f"sys_report/{report['sys_id']}",
@@ -1055,7 +1120,11 @@ def setup():
 
     # Save installation date
     logging.info("Saving installation date")
-    _set_sys_property(property_name="workarena.installation.date", value=datetime.now().isoformat())
+    set_sys_property(
+        instance=SNowInstance(),
+        property_name="workarena.installation.date",
+        value=datetime.now().isoformat(),
+    )
 
     logging.info("WorkArena setup complete.")
 
@@ -1065,10 +1134,29 @@ def main():
     Entrypoint for package CLI installation command
 
     """
+    parser = argparse.ArgumentParser(
+        description="Install WorkArena artifacts on a ServiceNow instance."
+    )
+    parser.add_argument(
+        "--instance-url", required=True, help="URL of the target ServiceNow instance."
+    )
+    parser.add_argument(
+        "--instance-password",
+        required=True,
+        help="Password for the admin user on the target ServiceNow instance.",
+    )
+    args = parser.parse_args()
+
+    global _CLI_INSTANCE_URL, _CLI_INSTANCE_PASSWORD
+    _CLI_INSTANCE_URL = args.instance_url
+    _CLI_INSTANCE_PASSWORD = args.instance_password
+
     logging.basicConfig(level=logging.INFO)
 
     try:
-        past_install_date = _get_sys_property("workarena.installation.date")
+        past_install_date = get_sys_property(
+            instance=SNowInstance(), property_name="workarena.installation.date"
+        )
         logging.info(f"Detected previous installation on {past_install_date}. Reinstalling...")
     except:
         past_install_date = "never"

browsergym/workarena/instance.py

@@ -1,11 +1,88 @@
+import base64
+import json
+import logging
 import os
+import random
 import requests
-import re
+from itertools import cycle
 
+from huggingface_hub import hf_hub_download
+from huggingface_hub.utils import disable_progress_bars
 from playwright.sync_api import sync_playwright
 from typing import Optional
 
-from .config import SNOW_BROWSER_TIMEOUT
+from .config import (
+    INSTANCE_REPO_FILENAME,
+    INSTANCE_REPO_ID,
+    INSTANCE_REPO_TYPE,
+    INSTANCE_XOR_SEED,
+    REPORT_FILTER_PROPERTY,
+    SNOW_BROWSER_TIMEOUT,
+)
+
+
+# Required to read the instance credentials
+if not INSTANCE_XOR_SEED:
+    raise ValueError("INSTANCE_XOR_SEED must be configured")
+
+
+def _xor_cipher(data: bytes, key: bytes) -> bytes:
+    return bytes(b ^ k for b, k in zip(data, cycle(key)))
+
+
+def decrypt_instance_password(encrypted_password: str) -> str:
+    """Decrypt a base64-encoded XOR-obfuscated password using the shared key."""
+
+    cipher_bytes = base64.b64decode(encrypted_password)
+    plain_bytes = _xor_cipher(cipher_bytes, INSTANCE_XOR_SEED.encode("utf-8"))
+    return plain_bytes.decode("utf-8")
+
+
+def encrypt_instance_password(password: str) -> str:
+    """Helper to produce encrypted passwords for populating the instance file."""
+
+    cipher_bytes = _xor_cipher(password.encode("utf-8"), INSTANCE_XOR_SEED.encode("utf-8"))
+    return base64.b64encode(cipher_bytes).decode("utf-8")
+
+
+def fetch_instances():
+    """
+    Load the latest instances from either a custom pool (SNOW_INSTANCE_POOL env var) or the gated HF dataset.
+    """
+    pool_path = os.getenv("SNOW_INSTANCE_POOL")
+    if pool_path:
+        path = os.path.expanduser(pool_path)
+        if not os.path.exists(path):
+            raise FileNotFoundError(
+                f"SNOW_INSTANCE_POOL points to '{pool_path}', but the file does not exist."
+            )
+        logging.info("Loading ServiceNow instances from custom pool: %s", path)
+    else:
+        try:
+            disable_progress_bars()
+            path = hf_hub_download(
+                repo_id=INSTANCE_REPO_ID,
+                filename=INSTANCE_REPO_FILENAME,
+                repo_type=INSTANCE_REPO_TYPE,
+            )
+            logging.info("Loaded ServiceNow instances from the default instance pool.")
+        except Exception as e:
+            raise RuntimeError(
+                f"Could not access {INSTANCE_REPO_ID}/{INSTANCE_REPO_FILENAME}. "
+                "Make sure you have been granted access to the gated repo and that you are "
+                "authenticated (run `huggingface-cli login` or set HUGGING_FACE_HUB_TOKEN)."
+            ) from e
+
+    with open(path, "r", encoding="utf-8") as f:
+        entries = json.load(f)
+
+    for entry in entries:
+        entry["url"] = entry["u"]
+        entry["password"] = decrypt_instance_password(entry["p"])
+        del entry["u"]
+        del entry["p"]
+
+    return entries
 
 
 class SNowInstance:
@@ -25,31 +102,39 @@ class SNowInstance:
         Parameters:
         -----------
         snow_url: str
-            The URL of a SNow instance. If None, will try to get the value from the environment variable SNOW_INSTANCE_URL.
+            The URL of a SNow instance. When omitted, the constructor first looks for SNOW_INSTANCE_URL and falls back
+            to a random instance from the benchmark's instance pool if the environment variable is not set.
         snow_credentials: (str, str)
-            The username and password used to access the SNow instance. If None, will try to get the values from the
-            environment variables SNOW_INSTANCE_UNAME and SNOW_INSTANCE_PWD.
+            The username and password used to access the SNow instance. When omitted, environment variables
+            SNOW_INSTANCE_UNAME/SNOW_INSTANCE_PWD are used if set; otherwise, a random instance from the benchmark's
+            instance pool is selected.
 
         """
         # try to get these values from environment variables if not provided
-        if snow_url is None:
-            if "SNOW_INSTANCE_URL" in os.environ:
+        if snow_url is None or snow_credentials is None:
+
+            # Check if all required environment variables are set and if yes, fetch url and credentials from there
+            if (
+                "SNOW_INSTANCE_URL" in os.environ
+                and "SNOW_INSTANCE_UNAME" in os.environ
+                and "SNOW_INSTANCE_PWD" in os.environ
+            ):
                 snow_url = os.environ["SNOW_INSTANCE_URL"]
-            else:
-                raise ValueError(
-                    f"Please provide a ServiceNow instance URL (you can use the environment variable SNOW_INSTANCE_URL)"
-                )
-
-        if snow_credentials is None:
-            if "SNOW_INSTANCE_UNAME" in os.environ and "SNOW_INSTANCE_PWD" in os.environ:
                 snow_credentials = (
                     os.environ["SNOW_INSTANCE_UNAME"],
                     os.environ["SNOW_INSTANCE_PWD"],
                 )
+
+            # Otherwise, load all instances and select one randomly
             else:
-                raise ValueError(
-                    f"Please provide ServiceNow credentials (you can use the environment variables SNOW_INSTANCE_UNAME and SNOW_INSTANCE_PWD)"
-                )
+                instances = fetch_instances()
+                if not instances:
+                    raise ValueError(
+                        f"No instances found in the dataset {INSTANCE_REPO_ID}. Please provide instance details via parameters or environment variables."
+                    )
+                instance = random.choice(instances)
+                snow_url = instance["url"]
+                snow_credentials = ("admin", instance["password"])
 
         # remove trailing slashes in the URL, if any
         self.snow_url = snow_url.rstrip("/")
@@ -124,3 +209,25 @@ class SNowInstance:
             browser.close()
 
         return release_info
+
+    @property
+    def report_filter_config(self) -> dict:
+        """
+        Get the report filter configuration from the ServiceNow instance.
+
+        Returns:
+        --------
+        dict
+            The report filter configuration, or an empty dictionary if not found.
+
+        """
+        from .api.system_properties import (
+            get_sys_property,
+        )  # Import here to avoid circular import issues
+
+        try:
+            config = get_sys_property(self, REPORT_FILTER_PROPERTY)
+            config = json.loads(config)
+            return config
+        except Exception:
+            return None

browsergym/workarena/tasks/dashboard.py

@@ -19,7 +19,6 @@ from ..config import (
     DASHBOARD_RETRIEVAL_VALUE_CONFIG_PATH,
     REPORT_RETRIEVAL_MINMAX_CONFIG_PATH,
     REPORT_RETRIEVAL_VALUE_CONFIG_PATH,
-    REPORT_DATE_FILTER,
     REPORT_PATCH_FLAG,
 )
 from ..instance import SNowInstance
@@ -295,9 +294,29 @@ class DashboardRetrievalTask(AbstractServiceNowTask, ABC):
             """,
         ]
 
+    def _get_filter_config(self) -> str:
+        # Get report filter config
+        config = self.instance.report_filter_config
+        if config is None:
+            REPORT_DATE_FILTER = REPORT_TIME_FILTER = None
+        else:
+            REPORT_DATE_FILTER = config["report_date_filter"]
+            REPORT_TIME_FILTER = config["report_time_filter"]
+        del config
+
+        # Check that the report filters are properly setup
+        if REPORT_DATE_FILTER is None or REPORT_TIME_FILTER is None:
+            raise RuntimeError(
+                "The report date and time filters are not set. Please run the install script to set them."
+            )
+        return REPORT_DATE_FILTER, REPORT_TIME_FILTER
+
     def setup_goal(self, page: playwright.sync_api.Page) -> Tuple[str | dict]:
         super().setup_goal(page=page)
 
+        # Get the instance report filter config
+        REPORT_DATE_FILTER, REPORT_TIME_FILTER = self._get_filter_config()
+
         # Configure task
         # ... sample a configuration
         self.config = (
@@ -305,7 +324,9 @@ class DashboardRetrievalTask(AbstractServiceNowTask, ABC):
         )
         # ... set start URL based on config
         # ...... some of the reports have need a date filter to be applied so we do this by patching a placeholder in the URL
-        self.start_url = self.instance.snow_url + self.config["url"]
+        self.start_url = self.instance.snow_url + self.config["url"].replace(
+            "REPORT_DATE_FILTER", REPORT_DATE_FILTER
+        ).replace("REPORT_TIME_FILTER", REPORT_TIME_FILTER)
 
         # Produce goal string based on question type
         chart_locator = (
@@ -616,6 +637,15 @@ class DashboardRetrievalTask(AbstractServiceNowTask, ABC):
             The types of questions to sample from (uniformely)
 
         """
+        # Get the instance report filter config
+        REPORT_DATE_FILTER, REPORT_TIME_FILTER = self._get_filter_config()
+
+        # Check that the report filters are properly setup
+        if REPORT_DATE_FILTER is None or REPORT_TIME_FILTER is None:
+            raise RuntimeError(
+                "The report date and time filters are not set. Please run the install script to set them."
+            )
+
         # Generate a bunch of reports based on valid table fields
         ON_THE_FLY_REPORTS = []
         for table in [
@@ -678,7 +708,7 @@ class DashboardRetrievalTask(AbstractServiceNowTask, ABC):
             # On the fly generated report
             if not report.get("sys_id", None):
                 # ... these receive a filter that is added through the URL
-                url = f"/now/nav/ui/classic/params/target/sys_report_template.do%3Fsysparm_field%3D{report['field']}%26sysparm_type%3D{report['type']}%26sysparm_table%3D{report['table']}%26sysparm_from_list%3Dtrue%26sysparm_chart_size%3Dlarge%26sysparm_manual_labor%3Dtrue%26sysparm_query=sys_created_on<javascript:gs.dateGenerate('{REPORT_DATE_FILTER}','00:00:00')^EQ"
+                url = f"/now/nav/ui/classic/params/target/sys_report_template.do%3Fsysparm_field%3D{report['field']}%26sysparm_type%3D{report['type']}%26sysparm_table%3D{report['table']}%26sysparm_from_list%3Dtrue%26sysparm_chart_size%3Dlarge%26sysparm_manual_labor%3Dtrue%26sysparm_query=sys_created_on<javascript:gs.dateGenerate('{REPORT_DATE_FILTER}','{REPORT_TIME_FILTER}')^EQ"
             # Report from the database
             else:
                 url = f"/now/nav/ui/classic/params/target/sys_report_template.do%3Fjvar_report_id={report['sys_id']}"
@@ -776,7 +806,7 @@ class SingleChartMeanMedianModeRetrievalTask(
 
 
 class WorkLoadBalancingMinMaxRetrievalTask(
-    MultiChartMinMaxRetrievalTask, CompositionalBuildingBlockTask
+    SingleChartMinMaxRetrievalTask, CompositionalBuildingBlockTask
 ):
     def all_configs(self):
         return json.load(open(REPORT_RETRIEVAL_MINMAX_CONFIG_PATH, "r"))

browsergym/workarena/tasks/scripts/generate_dashboard_configs.py

@@ -15,7 +15,6 @@ from playwright.sync_api import sync_playwright
 
 from browsergym.workarena.api.utils import table_api_call, table_column_info
 from browsergym.workarena.config import (
-    REPORT_DATE_FILTER,
     REPORT_PATCH_FLAG,
     REPORT_RETRIEVAL_MINMAX_CONFIG_PATH,
     REPORT_RETRIEVAL_VALUE_CONFIG_PATH,
@@ -44,6 +43,10 @@ class DummyDashboard(DashboardRetrievalTask):
 
 
 def get_report_urls(instance):
+    # Get the instance report filter config
+    REPORT_DATE_FILTER, REPORT_TIME_FILTER = instance._get_filter_config()
+    raise NotImplementedError("TODO: Include the time filter as in dashboard.py")
+
     # Generate a bunch of reports on the fly based on valid table fields
     ON_THE_FLY_REPORTS = []
     for table in [
@@ -226,7 +229,13 @@ def get_all_configs_by_url(url, is_report):
 
 
 if __name__ == "__main__":
-    instance = SNowInstance()
+
+    # XXX: Make sure to specific the exact instance on which to generate configs (and not use a random one)
+    raise NotImplementedError(
+        "Make sure to specific instance URL and credentials below, then comment this line."
+    )
+    instance = SNowInstance(snow_url=None, snow_credentials=None)
+
     reports = get_report_urls(instance)
     gen_func = partial(get_all_configs_by_url, is_report=REPORT)
 

browsergym/workarena/tasks/scripts/{navigation.py → generate_navigation_tasks.py}

@@ -6,7 +6,10 @@ NUM_CONFIGS = 650  # number of impersonation tasks in the paper
 
 
 def get_all_impersonation_users():
-    instance = SNowInstance()
+    raise NotImplementedError(
+        "Make sure to specific instance URL and credentials below, then comment this line."
+    )
+    instance = SNowInstance(snow_url=None, snow_credentials=None)
     candidate_users = [
         u["first_name"] + " " + u["last_name"]
         for u in table_api_call(

browsergym/workarena/tasks/scripts/knowledge.py

@@ -1,3 +1,4 @@
+# TODO: Can we delete this file?
 import json
 import random
 
@@ -9,9 +10,8 @@ from tenacity import retry, stop_after_attempt
 from tqdm import tqdm
 
 
-def generate_all_kb_configs(instance=None, num_configs=1000) -> list[dict]:
+def generate_all_kb_configs(instance, num_configs=1000) -> list[dict]:
     """Generate all possible KB configs"""
-    instance = instance if instance is not None else SNowInstance()
     with open(KB_FILEPATH, "r") as f:
         kb_entries = json.load(f)
     all_configs = []
@@ -33,5 +33,7 @@ def generate_all_kb_configs(instance=None, num_configs=1000) -> list[dict]:
 
 
 if __name__ == "__main__":
-
-    validate_kb_configs()
+    raise NotImplementedError(
+        "Make sure to specific instance URL and credentials below, then comment this line."
+    )
+    generate_all_kb_configs(instance=SNowInstance(snow_url=None))