Ref: Change get_agent and prompt rendering (needs to use tournament)

Author: klieret

codeclash/agents/__init__.py

@@ -1,33 +1,18 @@
+from minisweagent.environments.docker import DockerEnvironment
+
 from codeclash.agents.abstract import Player
 from codeclash.agents.dummy import Dummy
 from codeclash.agents.minisweagent import MiniSWEAgent
 from codeclash.agents.utils import GameContext
-from codeclash.constants import DIR_WORK
-from codeclash.games.abstract import CodeGame
 
 
-def get_agent(config: dict, prompts: dict, game: CodeGame) -> Player:
+def get_agent(
+    config: dict, game_context: GameContext, environment: DockerEnvironment
+) -> Player:
     agents = {
         "dummy": Dummy,
         "mini": MiniSWEAgent,
     }.get(config["agent"])
     if agents is None:
         raise ValueError(f"Unknown agent type: {config['agent']}")
-    environment = game.get_environment(
-        f"{game.game_id}.{config['name']}"
-    )  # NOTE: MUST be branch_name (defined in agents/abstract.py)
-    return agents(
-        config,
-        environment,
-        GameContext(
-            id=game.game_id,
-            log_env=game.log_env,
-            log_local=game.log_local,
-            name=game.name,
-            player_id=config["name"],
-            prompts=prompts,
-            round=1,
-            rounds=game.rounds,
-            working_dir=str(DIR_WORK),
-        ),
-    )
+    return agents(config, environment, game_context)

codeclash/agents/abstract.py

@@ -27,7 +27,6 @@ def __init__(
         """Unique ID that doesn't clash even accross multiple games. Used for git tags."""
         self.environment = environment
         self.game_context = game_context
-        self.game_context.render_and_set_prompts()
         self.logger = get_logger(
             self.name,
             log_path=self.game_context.log_local / f"{self.name}.log",
@@ -47,7 +46,6 @@ def pre_run_hook(self, *, new_round: int) -> None:
         if new_round == 1:
             self._tag_round(0)
         self.game_context.round = new_round
-        self.game_context.render_and_set_prompts()
 
     def post_run_hook(self, *, round: int) -> None:
         """Should be called after we called the run method."""

codeclash/agents/minisweagent.py

@@ -8,8 +8,9 @@
 
 import yaml
 from jinja2 import Template
-from minisweagent import Environment, Model
+from minisweagent import Model
 from minisweagent.agents.default import AgentConfig, DefaultAgent
+from minisweagent.environments.docker import DockerEnvironment
 from minisweagent.models.litellm_model import LitellmModel
 from minisweagent.run.utils.save import save_traj
 from rich.console import Console
@@ -28,7 +29,7 @@ class ClashAgent(DefaultAgent):
     def __init__(
         self,
         model: Model,
-        env: Environment,
+        env: DockerEnvironment,
         name: str,
         game_context: GameContext,
         *,
@@ -56,7 +57,7 @@ def render_template(self, template: str, **kwargs) -> str:
             | asdict(self.env.config)
             | asdict(self.model.config)
             | platform.uname()._asdict()
-            | self.game_context.to_dict()
+            | self.game_context.to_template_vars()
         )
         return Template(template).render(**kwargs, **cs, **os.environ)
 
@@ -69,7 +70,7 @@ class MiniSWEAgent(Player):
     """Player with agentic code editing capabilities"""
 
     def __init__(
-        self, config: dict, environment: Environment, game_context: GameContext
+        self, config: dict, environment: DockerEnvironment, game_context: GameContext
     ):
         super().__init__(config, environment=environment, game_context=game_context)
 

codeclash/agents/utils.py

@@ -36,24 +36,15 @@ class GameContext:
     rounds: int
     working_dir: str
 
-    def render_and_set_prompts(self):
-        """Render and set prompts using the current game context."""
+    def _render_prompt_templates(self) -> dict:
         context = asdict(self)
-        del context["prompts"]
-        for key, template_str in self.prompts.items():
-            rendered = Template(template_str).render(**context)
-            setattr(self, key, rendered)
-
-    def to_dict(self):
-        """Convert the GameContext to a dictionary, including dynamically added attributes."""
-        result = asdict(self)
-        declared = set(self.__dataclass_fields__)
-        for attr in dir(self):
-            if (
-                not attr.startswith("_")
-                and attr not in declared
-                and not callable(getattr(self, attr))
-            ):
-                result[attr] = getattr(self, attr)
-        del result["prompts"]
-        return result
+        return {
+            key: Template(template_str).render(**context)
+            for key, template_str in self.prompts.items()
+        }
+
+    def to_template_vars(self) -> dict[str, str]:
+        """Convert the GameContext to a dictionary for rendering prompts in the agent"""
+        out = asdict(self) | self._render_prompt_templates()
+        out.pop("prompts")
+        return out

codeclash/games/abstract.py

@@ -2,7 +2,6 @@
 import os
 import subprocess
 from abc import ABC, abstractmethod
-from collections import Counter
 from pathlib import Path
 
 from minisweagent.environments.docker import DockerEnvironment
@@ -24,12 +23,15 @@ def __init__(self, config: dict, *, tournament_id: str, local_output_dir: Path):
         The central method is `run_round`, which takes a list of agents and returns the winner of the round.
 
         At the end of the the tournament, run the `end` method to clean up the game and agents and write the metadata.
+
+        Args:
+            config: The overall config for the tournament.
+            tournament_id: The id of the tournament.
+            local_output_dir: The host/local directory to write logs to.
         """
         self.url_gh: str = f"git@github.com:{GH_ORG}/{self.name}.git"
         self.artifacts: list[Path] = []
         """Artifact objects that we might want to clean up after the game."""
-        self.scoreboard: list[tuple[int, str]] = []
-        """List of (round number, winner (player id))"""
         self.game_config: dict = config["game"]
         self.config: dict = config
         self.game_id: str = tournament_id
@@ -40,8 +42,6 @@ def __init__(self, config: dict, *, tournament_id: str, local_output_dir: Path):
         )
         self.environment: DockerEnvironment = self.get_environment()
         """The running docker environment for executing the game"""
-        # assert len(config["players"]) >= 2, "At least two players are required"
-        """Total number of rounds to play"""
         self._metadata: dict = {
             "name": self.name,
             "config": self.config,
@@ -92,7 +92,6 @@ def get_metadata(self) -> dict:
         return self._metadata
 
     def end(self, cleanup: bool = False):
-        self.logger.info("Overall score: %s", Counter([x[1] for x in self.scoreboard]))
         (self.log_local / "metadata.json").write_text(json.dumps(self.get_metadata()))
         if cleanup:
             for artifact in self.artifacts:

codeclash/games/battlecode/main.py

@@ -1,4 +1,5 @@
 import re
+import shlex
 from pathlib import Path
 from typing import Any
 
@@ -52,7 +53,7 @@ def execute_round(self, agents: list[Any]) -> dict[str, str]:
             f"--p{idx+1}-dir src --p{idx+1} {agent.name}"
             for idx, agent in enumerate(agents)
         ]
-        cmd = f"{self.run_cmd_round} {' '.join(args)}"
+        cmd = f"{self.run_cmd_round} {shlex.join(args)}"
         self.logger.info(f"Running command: {cmd}")
         response = self.environment.execute(cmd)
         assert response["returncode"] == 0, response

codeclash/games/corewar/main.py

@@ -1,4 +1,5 @@
 import re
+import shlex
 from pathlib import Path
 
 from codeclash.agents.abstract import Player
@@ -52,7 +53,7 @@ def determine_winner(
 
     def execute_round(self, agents: list[Player]) -> dict[str, str]:
         args = [f"/{agent.name}/warriors/warrior.red" for agent in agents]
-        cmd = f"{self.run_cmd_round} {' '.join(args)}"
+        cmd = f"{self.run_cmd_round} {shlex.join(args)}"
         self.logger.info(f"Running command: {cmd}")
         response = self.environment.execute(cmd)
         assert response["returncode"] == 0, response

codeclash/games/robotrumble/main.py

@@ -1,3 +1,4 @@
+import shlex
 from pathlib import Path
 
 from codeclash.agents.abstract import Player
@@ -42,7 +43,7 @@ def determine_winner(
 
     def execute_round(self, agents: list[Player]) -> dict[str, str]:
         args = [f"/{agent.name}/robot.py" for agent in agents]
-        cmd = f"{self.run_cmd_round} {' '.join(args)}"
+        cmd = f"{self.run_cmd_round} {shlex.join(args)}"
         self.logger.info(f"Running command: {cmd}")
         response = self.environment.execute(cmd)
         assert response["returncode"] == 0, response

codeclash/tournaments/abstract.py

@@ -3,7 +3,10 @@
 import traceback
 from pathlib import Path
 
-from codeclash.constants import DIR_LOGS
+from codeclash.agents import get_agent
+from codeclash.agents.abstract import Player
+from codeclash.agents.utils import GameContext
+from codeclash.constants import DIR_LOGS, DIR_WORK
 from codeclash.utils.environment import create_file_on_container
 from codeclash.utils.log import get_logger
 

codeclash/tournaments/pvp_training.py

@@ -4,6 +4,8 @@
 
 from codeclash.agents import get_agent
 from codeclash.agents.abstract import Player
+from codeclash.agents.utils import GameContext
+from codeclash.constants import DIR_WORK
 from codeclash.games import get_game
 from codeclash.games.abstract import CodeGame
 from codeclash.tournaments.abstract import AbstractTournament
@@ -24,13 +26,38 @@ def __init__(
         )
         self.agents: list[Player] = []
         for agent_conf in self.config["players"]:
-            self.agents.append(get_agent(agent_conf, self.config["prompts"], self.game))
+            self.agents.append(self.get_agent(agent_conf, self.config["prompts"]))
         self.logger = get_logger(self.game.name)
+        self.scoreboard: list[tuple[int, str]] = []
+
+    @property
+    def rounds(self) -> int:
+        return self.config["game"]["rounds"]
+
+    def get_agent(self, agent_config: dict, prompts: dict) -> Player:
+        """Create an agent with environment and game context."""
+        environment = self.game.get_environment(
+            f"{self.game.game_id}.{agent_config['name']}"
+        )
+
+        game_context = GameContext(
+            id=self.game.game_id,
+            log_env=self.game.log_env,
+            log_local=self.game.log_local,
+            name=self.game.name,
+            player_id=agent_config["name"],
+            prompts=prompts,
+            round=1,
+            rounds=self.rounds,
+            working_dir=str(DIR_WORK),
+        )
+
+        return get_agent(agent_config, game_context, environment)
 
     def run(self) -> None:
         """Main execution function that runs all rounds."""
         try:
-            for round_num in range(1, self.game.rounds + 1):
+            for round_num in range(1, self.rounds + 1):
                 self.run_training_round(round_num)
         finally:
             self.cleanup()
@@ -44,7 +71,7 @@ def run_training_round(self, round_num: int) -> None:
         winner = result["winner"]
 
         # Handle bookkeeping that was previously in the game
-        self.game.scoreboard.append((round_num, winner))
+        self.scoreboard.append((round_num, winner))
         self.logger.info(f"Round {round_num} winner: {winner}")
 
         # Write log to file