add demo version

Author: jardinetsouffleton

browsergym/core/src/browsergym/core/env.py

@@ -584,3 +584,91 @@ def _get_obs(self):
         }
 
         return obs
+
+
+class BrowserEnvEnhanced(BrowserEnv):
+    def __init__(
+        self,
+        # task-related arguments
+        task_entrypoint: type[AbstractBrowserTask],
+        task_kwargs: dict = {},
+        viewport: Optional[dict] = None,  # will override the task's viewport
+        slow_mo: Optional[int] = None,  # will override the task's slow_mo
+        timeout: Optional[int] = None,  # will override the task's timeout
+        locale: Optional[str] = None,  # will override the task's locale
+        timezone_id: Optional[str] = None,  # will override the task's timezone_id
+        tags_to_mark: Literal["all", "standard_html"] = "standard_html",
+        # interactive / debugging arguments
+        headless: bool = True,
+        wait_for_user_message: bool = False,
+        terminate_on_infeasible: bool = True,
+        resizeable_window: bool = False,
+        record_video_dir: Optional[str] = None,
+        pw_chromium_kwargs: dict = {},
+        pw_context_kwargs: dict = {},
+        # agent-related arguments
+        action_mapping: Optional[callable] = HighLevelActionSet().to_python_code,
+    ):
+        super().__init__(
+            task_entrypoint=task_entrypoint,
+            task_kwargs=task_kwargs,
+            viewport=viewport,
+            slow_mo=slow_mo,
+            timeout=timeout,
+            locale=locale,
+            timezone_id=timezone_id,
+            tags_to_mark=tags_to_mark,
+            headless=headless,
+            wait_for_user_message=wait_for_user_message,
+            terminate_on_infeasible=terminate_on_infeasible,
+            resizeable_window=resizeable_window,
+            record_video_dir=record_video_dir,
+            pw_chromium_kwargs=pw_chromium_kwargs,
+            pw_context_kwargs=pw_context_kwargs,
+            action_mapping=action_mapping,
+        )
+        self.replacements = [
+            "test",
+            "test2",
+        ]
+
+    def reset(self, seed=None, *args, **kwargs):
+        obs, info = super().reset(seed=seed, *args, **kwargs)
+        self.alter_env()
+        obs = self._get_obs()
+
+        return obs, info
+
+    def step(self, action: str):
+        obs, reward, done, truncated, info = super().step(action)
+        self.alter_env()
+        obs = self._get_obs()
+
+        successful_change = self.successful_change(obs)
+
+        if successful_change:
+            reward = 0
+            done = True
+            if not info:
+                info = {"success": True}
+
+        return obs, reward, done, truncated, info
+
+    def alter_env(self):
+        content_selector = "div[id$='-comment-rtjson-content']"
+        self.injection_script = f"""
+            (replacements) => {{
+                // If flag is already set, do nothing
+
+                // Replace content
+                const elements = document.querySelectorAll("{content_selector}");
+                replacements.forEach((newText, index) => {{
+                    // Only process if we have a corresponding element
+                    if (index < elements.length && newText !== null) {{
+                        elements[index].textContent = newText;
+                    }}
+                }});
+                return true;
+            }}
+        """
+        self.page.evaluate(self.injection_script, self.replacements)

browsergym/core/src/browsergym/core/registration.py

@@ -3,7 +3,7 @@
 
 import gymnasium as gym
 
-from .env import BrowserEnv
+from .env import BrowserEnvEnhanced
 from .task import AbstractBrowserTask
 
 
@@ -67,7 +67,7 @@ def register_task(
 
     gym.register(
         id=f"browsergym/{id}",
-        entry_point=lambda *env_args, **env_kwargs: BrowserEnv(
+        entry_point=lambda *env_args, **env_kwargs: BrowserEnvEnhanced(
             task_entrypoint, *env_args, **env_kwargs
         ),
         nondeterministic=nondeterministic,

browsergym/experiments/src/browsergym/experiments/reset_loop.py

@@ -0,0 +1,160 @@
+"""
+    utils for restoring browser state from a previous session
+"""
+
+import logging
+import traceback
+import re
+
+from browsergym.experiments.loop import (
+    ExpArgs,
+    StepInfo,
+    _send_chat_info,
+    _save_summary_info,
+    save_package_versions,
+    _is_debugging,
+)
+from dataclasses import dataclass
+from browsergym.core.action.parsers import highlevel_action_parser
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ExpArgsWithReset(ExpArgs):
+    def run(self, previous_actions=[]):
+        """
+        Execute the same actions as expert for the list |previous_actions| of expert actions.
+        """
+        # start writing logs to run logfile
+        self._set_logger()
+
+        # log python environment info
+        save_package_versions(self.exp_dir)
+
+        episode_info = []
+        env, step_info, err_msg, stack_trace = None, None, None, None
+        try:
+            logger.info(f"Running experiment {self.exp_name} in:\n  {self.exp_dir}")
+            agent = self.agent_args.make_agent()
+            logger.debug(f"Agent created.")
+            env = self.env_args.make_env(
+                action_mapping=agent.action_set.to_python_code, exp_dir=self.exp_dir
+            )
+            logger.debug(f"Environment created.")
+
+            step_info = StepInfo(step=0)
+            episode_info = [step_info]
+            step_info.from_reset(
+                env, seed=self.env_args.task_seed, obs_preprocessor=agent.obs_preprocessor
+            )
+            logger.debug(f"Environment reset.")
+
+            while not step_info.is_done:  # set a limit
+                # get the current time step
+                time_step = step_info.step
+                logger.debug(f"Starting step {step_info.step}.")
+                if time_step < len(previous_actions):
+                    curr_obs = step_info.obs.copy()
+                    expert_obs, expert_action = previous_actions[time_step]
+                    curr_obs["expert_observation"] = expert_obs
+                    curr_obs["expert_action"] = expert_action
+
+                    # parse the action to get BID
+                    exp_action_parsed = highlevel_action_parser.parse_string(
+                        expert_action
+                    ).as_list()[0]
+                    if exp_action_parsed[0] in ["click", "hover", "fill"]:
+                        bid = exp_action_parsed[1][0]
+                        try:
+                            bid_info = [
+                                o
+                                for o in expert_obs["axtree_object"]["nodes"]
+                                if "browsergym_id" in o and o["browsergym_id"] == bid
+                            ]
+                            if len(bid_info) == 0:
+                                action = expert_action
+                                agent_info = {}
+                            else:
+                                bid_value = bid_info[0]["name"]["value"]
+                                new_bid = [
+                                    o["browsergym_id"]
+                                    for o in curr_obs["axtree_object"]["nodes"]
+                                    if "browsergym_id" in o and o["name"]["value"] == bid_value
+                                ][0]
+                                action = re.sub(bid, new_bid, expert_action)
+                                agent_info = {}
+                        except:
+                            raise ValueError("Could not find the BID in the expert observation")
+                    else:
+                        action = expert_action
+                        agent_info = {}
+
+                    step_info.action = action
+                    step_info.agent_info = agent_info
+                    logger.debug(f"Restoring action from previous actions:\n {action}")
+                else:
+                    logger.debug(f"No more actions to replay. Ending episode.")
+                    break
+
+                if action is None:
+                    # will end the episode after saving the step info.
+                    step_info.truncated = True
+
+                step_info.save_step_info(
+                    self.exp_dir, save_screenshot=self.save_screenshot, save_som=self.save_som
+                )
+                logger.debug(f"Step info saved.")
+
+                _send_chat_info(env.unwrapped.chat, action, step_info.agent_info)
+                logger.debug(f"Chat info sent.")
+
+                if action is None:
+                    logger.debug(f"Agent returned None action. Ending episode.")
+                    break
+
+                step_info = StepInfo(step=step_info.step + 1)
+                episode_info.append(step_info)
+
+                logger.debug(f"Sending action to environment.")
+                step_info.from_step(env, action, obs_preprocessor=agent.obs_preprocessor)
+                logger.debug(f"Environment stepped.")
+
+        except Exception as e:
+            err_msg = f"Exception uncaught by agent or environment in task {self.env_args.task_name}.\n{type(e).__name__}:\n{e}"
+            stack_trace = traceback.format_exc()
+
+            self.err_msg = err_msg
+            self.stack_trace = stack_trace
+
+            logger.warning(err_msg + "\n" + stack_trace)
+            if _is_debugging() and self.enable_debug:
+                raise
+        finally:
+            try:
+                if step_info is not None:
+                    step_info.save_step_info(
+                        self.exp_dir, save_screenshot=self.save_screenshot, save_som=self.save_som
+                    )
+            except Exception as e:
+                logger.error(f"Error while saving step info in the finally block: {e}")
+            try:
+                if (
+                    not err_msg
+                    and len(episode_info) > 0
+                    and not (episode_info[-1].terminated or episode_info[-1].truncated)
+                ):
+                    e = KeyboardInterrupt("Early termination??")
+                    err_msg = f"Exception uncaught by agent or environment in task {self.env_args.task_name}.\n{type(e).__name__}:\n{e}"
+                _save_summary_info(episode_info, self.exp_dir, err_msg, stack_trace)
+            except Exception as e:
+                logger.error(f"Error while saving summary info in the finally block: {e}")
+            try:
+                if env is not None:
+                    env.close()
+            except Exception as e:
+                logger.error(f"Error while closing the environment in the finally block: {e}")
+            try:
+                self._unset_logger()  # stop writing logs to run logfile
+            except Exception as e:
+                logger.error(f"Error while unsetting the logger in the finally block: {e}")

demo_agent/requirements.txt

@@ -1,2 +1,3 @@
 browsergym
+-e ../browsergym/core
 openai

demo_agent/run_demo.py

@@ -2,6 +2,8 @@
 
 # locally defined agent
 from agent import DemoAgentArgs
+import sys
+
 
 # browsergym experiments utils
 from browsergym.experiments import EnvArgs, ExpArgs, get_exp_result
@@ -23,7 +25,7 @@ def parse_args():
     parser.add_argument(
         "--model_name",
         type=str,
-        default="gpt-4o-mini",
+        default="gpt-4o",
         help="OpenAI model name.",
     )
     parser.add_argument(
@@ -35,7 +37,7 @@ def parse_args():
     parser.add_argument(
         "--start_url",
         type=str,
-        default="https://www.google.com",
+        default="https://www.reddit.com/r/AdvancedRunning/comments/1ie1ozg/312_marathoner_looking_for_help_in_preparing_for/",
         help="Starting URL (only for the openended task).",
     )
     parser.add_argument(