Ref: Avoid circular dependency Game <> Player

Closes #18

Author: klieret

codeclash/agents/__init__.py

@@ -11,4 +11,10 @@ def get_agent(config: dict, game: CodeGame) -> Player:
     }.get(config["agent"])
     if agents is None:
         raise ValueError(f"Unknown agent type: {config['agent']}")
-    return agents(config, game)
+    environment = game.get_environment()
+    format_vars = {
+        "game_id": game.game_id,
+        "rounds": game.rounds,
+        "round": game.round,
+    }
+    return agents(config, environment, format_vars)

codeclash/agents/abstract.py

@@ -3,30 +3,35 @@
 
 from dotenv import load_dotenv
 from ghapi.all import GhApi
+from minisweagent import Environment
 
 from codeclash.constants import GH_ORG
-from codeclash.games.abstract import CodeGame
 
 load_dotenv()
 
 
 class Player(ABC):
-    def __init__(self, config: dict, game: CodeGame):
+    def __init__(
+        self,
+        config: dict,
+        environment: Environment,
+        format_vars: dict,
+    ):
         self.config = config
-        self.name = f"{game.game_id}_{config['name']}"
-        self.container = game.get_environment()
-        self.game = game
+        self.name = f"{format_vars['game_id']}_{config['name']}"
+        self.environment = environment
+        self.round = format_vars["round"]
+        self.format_vars = format_vars
 
     def commit(self):
         """Commit changes to the agent's codebase."""
+        rounds = self.format_vars["rounds"]
         for cmd in [
             "git add -A",
-            f"git commit --allow-empty -m 'Round {self.game.round}/{self.game.rounds} Update'",
+            f"git commit --allow-empty -m 'Round {self.round}/{rounds} Update'",
         ]:
-            self.container.execute(cmd)
-        print(
-            f"Committed changes for {self.name} for round {self.game.round}/{self.game.rounds}"
-        )
+            self.environment.execute(cmd)
+        print(f"Committed changes for {self.name} for round {self.round}/{rounds}")
 
     def push(self):
         """Push codebase to a new repository."""
@@ -41,7 +46,7 @@ def push(self):
             f"git remote add origin https://x-access-token:{token}@github.com/{GH_ORG}/{self.name}.git",
             "git push -u origin main",
         ]:
-            self.container.execute(cmd)
+            self.environment.execute(cmd)
 
     @abstractmethod
     def run(self):

codeclash/agents/dummy.py

@@ -4,8 +4,5 @@
 class Dummy(Player):
     """A dummy player that does nothing. Mainly for testing purposes."""
 
-    def __init__(self, config: dict, game):
-        super().__init__(config, game)
-
     def run(self):
         self.commit()

codeclash/agents/minisweagent.py

@@ -15,7 +15,6 @@
 
 from codeclash.agents.abstract import Player
 from codeclash.agents.utils import resolve_api_key
-from codeclash.games.abstract import CodeGame
 
 
 class ClashAgent(DefaultAgent):
@@ -29,14 +28,14 @@ def __init__(
         model: Model,
         env: Environment,
         name: str,
-        game: CodeGame,
+        format_vars: dict,
         *,
         config_class: Callable = AgentConfig,
         **kwargs,
     ):
         super().__init__(model, env, config_class=config_class, **kwargs)
         self.name = name
-        self.game = game
+        self.format_vars = format_vars
         self.console = Console()
 
     def add_message(self, role: str, content: str, **kwargs):
@@ -52,10 +51,7 @@ def render_template(self, template: str, **kwargs) -> str:
             | asdict(self.env.config)
             | asdict(self.model.config)
             | platform.uname()._asdict()
-            | {
-                "rounds": self.game.rounds,
-                "round": self.game.round,
-            }
+            | self.format_vars
         )
         return Template(template).render(**kwargs, **cs, **os.environ)
 
@@ -68,16 +64,16 @@ def run(self) -> tuple[str, str]:
 class MiniSWEAgent(Player):
     """Player with agentic code editing capabilities"""
 
-    def __init__(self, config: dict, game: CodeGame):
-        super().__init__(config, game)
+    def __init__(self, config: dict, environment: Environment, format_vars: dict):
+        super().__init__(config, environment=environment, format_vars=format_vars)
         self.agent = ClashAgent(
             LitellmModel(
                 model_name=config["model"],
                 model_kwargs={"api_key": resolve_api_key(config["model"])},
             ),
-            self.container,
+            self.environment,
             self.name,
-            game,
+            format_vars,
             **yaml.safe_load(Path(config["config"]).read_text())["agent"],
         )
 
@@ -94,7 +90,7 @@ def run(self):
         finally:
             save_traj(
                 self.agent,  # type: ignore
-                Path(f"{self.name}_r{self.game.round}.traj.json"),
+                Path(f"{self.name}_r{self.format_vars['round']}.traj.json"),
                 exit_status=exit_status,
                 result=result,
             )

codeclash/games/abstract.py

@@ -100,7 +100,7 @@ def _pre_round_setup(self, agents: list[Any]):
         # Copy agent codebases into game's container
         for agent in agents:
             copy_between_containers(
-                src_container=agent.container,
+                src_container=agent.environment,
                 dest_container=self.environment,
                 src_path=DIR_WORK,
                 dest_path=f"/{agent.name}",
@@ -124,9 +124,9 @@ def _post_round_setup(self, agents: list[Any]):
         for agent in agents:
             copy_between_containers(
                 self.environment,
-                agent.container,
+                agent.environment,
                 self.round_log_path,
-                f"{agent.container.config.cwd}/logs/round_{self.round}.log",
+                f"{agent.environment.config.cwd}/logs/round_{self.round}.log",
             )
             print(f"Copied round log to {agent.name}'s container.")
         print(f"Round {self.round} completed.")