Move from black/isort to ruff linting

Author: john-b-yang

.pre-commit-config.yaml

@@ -1,6 +1,9 @@
+ci:
+  autoupdate_commit_msg: "chore: update pre-commit hooks"
+
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
+    rev: v6.0.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
@@ -9,14 +12,24 @@ repos:
       - id: check-merge-conflict
       - id: debug-statements
 
-  - repo: https://github.com/psf/black
-    rev: 23.3.0
+  - repo: https://github.com/crate-ci/typos
+    rev: v1
+    hooks:
+      - id: typos
+        files: \.(py|md|rst|yaml|toml)
+        exclude: pyproject.toml
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.12.10
     hooks:
-      - id: black
-        language_version: python3
+      # Run the linter.
+      - id: ruff
+        args: ["--fix"]
+      # Run the formatter.
+      - id: ruff-format
 
-  - repo: https://github.com/pycqa/isort
-    rev: 5.12.0
+  - repo: https://github.com/pre-commit/mirrors-prettier
+    rev: "v4.0.0-alpha.8" # Use the sha or tag you want to point at
     hooks:
-      - id: isort
-        args: ["--profile", "black"]
+      - id: prettier
+        types_or: ["javascript", "css"]

codeclash/agents/__init__.py

@@ -6,9 +6,7 @@
 from codeclash.agents.utils import GameContext
 
 
-def get_agent(
-    config: dict, game_context: GameContext, environment: DockerEnvironment
-) -> Player:
+def get_agent(config: dict, game_context: GameContext, environment: DockerEnvironment) -> Player:
     agents = {
         "dummy": Dummy,
         "mini": MiniSWEAgent,

codeclash/agents/abstract.py

@@ -24,7 +24,7 @@ def __init__(
         self.config = config
         self.name = config["name"]
         self._player_unique_id = uuid.uuid4()
-        """Unique ID that doesn't clash even accross multiple games. Used for git tags."""
+        """Unique ID that doesn't clash even across multiple games. Used for git tags."""
         self.environment = environment
         self.game_context = game_context
         self.logger = get_logger(
@@ -51,9 +51,7 @@ def post_run_hook(self, *, round: int) -> None:
         """Should be called after we called the run method."""
         self._commit()
         self._metadata["diff"][round] = self._get_round_diff(round)
-        self._metadata["incremental_diff"][round] = self._get_round_diff(
-            round, incremental=True
-        )
+        self._metadata["incremental_diff"][round] = self._get_round_diff(round, incremental=True)
 
     @abstractmethod
     def run(self) -> None:
@@ -76,23 +74,15 @@ def push(self) -> None:
             "git push origin --tags",
         ]:
             assert_zero_exit_code(self.environment.execute(cmd), logger=self.logger)
-        self.logger.info(
-            f"Pushed {self.name} commit history to remote repository (branch {self._branch_name})"
-        )
+        self.logger.info(f"Pushed {self.name} commit history to remote repository (branch {self._branch_name})")
 
-    def reset_and_apply_patch(
-        self, patch: str, *, base_commit: str = "", filter_patch: bool = True
-    ) -> None:
-        """Clean all uncommited changes. If base_commit is provided, reset to that commit.
+    def reset_and_apply_patch(self, patch: str, *, base_commit: str = "", filter_patch: bool = True) -> None:
+        """Clean all uncommitted changes. If base_commit is provided, reset to that commit.
         Then apply the patch to the codebase.
         """
         # Need to clean before we copy over the patch (else it's gonna be removed by git clean)
         self.logger.debug(
-            assert_zero_exit_code(
-                self.environment.execute(
-                    f"git reset --hard {base_commit} && git clean -fd"
-                )
-            )
+            assert_zero_exit_code(self.environment.execute(f"git reset --hard {base_commit} && git clean -fd"))
         )
 
         patch = filter_git_diff(patch) if filter_patch else patch
@@ -112,19 +102,15 @@ def reset_and_apply_patch(
         commands = ["git status", "git apply tmp_patch.txt", "rm -f tmp_patch.txt"]
         for cmd in commands:
             self.logger.debug(f"Executing command: {cmd}")
-            out = assert_zero_exit_code(
-                self.environment.execute(cmd), logger=self.logger
-            )
+            out = assert_zero_exit_code(self.environment.execute(cmd), logger=self.logger)
             self.logger.debug(out)
 
     # --- Helper methods ---
 
     def _tag_round(self, round: int) -> None:
         """Git tag the codebase at the given round."""
         assert_zero_exit_code(
-            self.environment.execute(
-                f"git tag -a {self._get_round_tag_name(round)} -m 'Round {round} Update'"
-            ),
+            self.environment.execute(f"git tag -a {self._get_round_tag_name(round)} -m 'Round {round} Update'"),
             logger=self.logger,
         )
 
@@ -161,9 +147,7 @@ def _get_round_diff(self, round: int, *, incremental: bool = False) -> str:
             previous_round_tag = self._get_round_tag_name(0)
         current_round_tag = self._get_round_tag_name(round)
         out = assert_zero_exit_code(
-            self.environment.execute(
-                f"git diff {previous_round_tag}..{current_round_tag}"
-            ),
+            self.environment.execute(f"git diff {previous_round_tag}..{current_round_tag}"),
             logger=self.logger,
         )
         return out["output"]

codeclash/agents/minisweagent.py

@@ -47,9 +47,7 @@ def add_message(self, role: str, content: str, **kwargs):
         super().add_message(role, content, **kwargs)
         self.logger.debug(f"[{role}] {content}", extra={"highlighter": None})
         if role == "assistant":
-            self.logger.info(
-                f"Step taken (step {self.model.n_calls}, cost {self.model.cost:.2f})"
-            )
+            self.logger.info(f"Step taken (step {self.model.n_calls}, cost {self.model.cost:.2f})")
 
     def render_template(self, template: str, **kwargs) -> str:
         cs = (
@@ -69,9 +67,7 @@ def run(self) -> tuple[str, str]:
 class MiniSWEAgent(Player):
     """Player with agentic code editing capabilities"""
 
-    def __init__(
-        self, config: dict, environment: DockerEnvironment, game_context: GameContext
-    ):
+    def __init__(self, config: dict, environment: DockerEnvironment, game_context: GameContext):
         super().__init__(config, environment=environment, game_context=game_context)
 
     def run(self):
@@ -96,10 +92,7 @@ def run(self):
             result = exc_message
             print(exc_message)
         finally:
-            traj_path = (
-                self.game_context.log_local
-                / f"{self.name}_r{self.game_context.round}.traj.json"
-            )
+            traj_path = self.game_context.log_local / f"{self.name}_r{self.game_context.round}.traj.json"
             save_traj(
                 self.agent,  # type: ignore
                 traj_path,

codeclash/agents/utils.py

@@ -13,6 +13,7 @@ def resolve_api_key(model: str) -> str:
         return os.getenv("ANTHROPIC_API_KEY")
     if "gpt" in model:
         return os.getenv("OPENAI_API_KEY")
+    return ""
 
 
 @dataclass
@@ -38,10 +39,7 @@ class GameContext:
 
     def _render_prompt_templates(self) -> dict:
         context = asdict(self)
-        return {
-            key: Template(template_str).render(**context)
-            for key, template_str in self.prompts.items()
-        }
+        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"""

codeclash/games/abstract.py

@@ -17,9 +17,7 @@
 @dataclass
 class RoundStats:
     winner: str
-    scores: dict[
-        str, float
-    ]  # Map of player to game metric (e.g. # of wins, assets accumulated)
+    scores: dict[str, float]  # Map of player to game metric (e.g. # of wins, assets accumulated)
     details: dict[str, Any] = None  # Optional, for game-specific info
 
     def __str__(self) -> str:
@@ -63,9 +61,7 @@ def __init__(self, config: dict, *, tournament_id: str, local_output_dir: Path):
         self.game_id: str = tournament_id
         self.log_env: Path = (DIR_WORK / DIR_LOGS / self.game_id).resolve()
         self.log_local: Path = local_output_dir
-        self.logger = get_logger(
-            self.name, log_path=self.log_local / "game.log", emoji="🏓"
-        )
+        self.logger = get_logger(self.name, log_path=self.log_local / "game.log", emoji="🏓")
         self.environment: DockerEnvironment = self.get_environment()
         """The running docker environment for executing the game"""
         self._metadata: dict = {
@@ -106,9 +102,7 @@ def build_image(self):
         if result.returncode == 0:
             self.logger.info(f"✅ Built Docker image {self.image_name}")
         else:
-            self.logger.error(
-                f"❌ Failed to build Docker image: {result.stderr}\n{result.stdout}{result.stderr}"
-            )
+            self.logger.error(f"❌ Failed to build Docker image: {result.stderr}\n{result.stdout}{result.stderr}")
             raise RuntimeError(f"Failed to build Docker image: {result.stderr}")
 
     def get_metadata(self) -> dict:

codeclash/games/battlecode/main.py

@@ -12,9 +12,7 @@ class BattleCodeGame(CodeGame):
     name: str = "BattleCode"
 
     def __init__(self, config, *, tournament_id: str, local_output_dir: Path):
-        super().__init__(
-            config, tournament_id=tournament_id, local_output_dir=local_output_dir
-        )
+        super().__init__(config, tournament_id=tournament_id, local_output_dir=local_output_dir)
         assert len(config["players"]) == 2, "BattleCode is a two-player game"
         self.run_cmd_round: str = "python run.py run"
         for arg, val in self.game_config.get("args", {}).items():
@@ -36,9 +34,7 @@ def get_stats(self, result_outputs: list[str], agents: list[Any]) -> RoundStats:
                 winner_key = match.group(1)
                 self.logger.debug(f"Winner key from match: {winner_key}")
                 # Map A/B to actual agent names (much closer to original code)
-                winner = {"A": agents[0].name, "B": agents[1].name}.get(
-                    winner_key, RESULT_TIE
-                )
+                winner = {"A": agents[0].name, "B": agents[1].name}.get(winner_key, RESULT_TIE)
                 winners.append(winner)
             else:
                 winners.append(RESULT_TIE)
@@ -49,14 +45,9 @@ def get_stats(self, result_outputs: list[str], agents: list[Any]) -> RoundStats:
 
     def execute_round(self, agents: list[Any]) -> RoundData:
         for agent in agents:
-            src, dest = f"/{agent.name}/src/mysubmission/", str(
-                DIR_WORK / "src" / agent.name
-            )
+            src, dest = f"/{agent.name}/src/mysubmission/", str(DIR_WORK / "src" / agent.name)
             self.environment.execute(f"cp -r {src} {dest}")
-        args = [
-            f"--p{idx+1}-dir src --p{idx+1} {agent.name}"
-            for idx, agent in enumerate(agents)
-        ]
+        args = [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)}"
         self.logger.info(f"Running game: {cmd}")
         outputs = []

codeclash/games/battlesnake/main.py

@@ -14,9 +14,7 @@ class BattleSnakeGame(CodeGame):
     name: str = "BattleSnake"
 
     def __init__(self, config, *, tournament_id: str, local_output_dir: Path):
-        super().__init__(
-            config, tournament_id=tournament_id, local_output_dir=local_output_dir
-        )
+        super().__init__(config, tournament_id=tournament_id, local_output_dir=local_output_dir)
         self.run_cmd_round: str = "./battlesnake play"
         for arg, val in self.game_config.get("args", {}).items():
             if isinstance(val, bool):
@@ -29,9 +27,7 @@ def get_stats(self, result_outputs: list[str], agents: list[Player]) -> RoundSta
         winners = []
         for ro in result_outputs:
             lines = ro.strip().split("\n")
-            last_line = (
-                lines[-1] if lines else ""
-            )  # Get the last line which contains the game result
+            last_line = lines[-1] if lines else ""  # Get the last line which contains the game result
             winner = json.loads(last_line)["winnerName"]
             winners.append(winner)
 
@@ -48,9 +44,7 @@ def execute_round(self, agents: list[Player]) -> RoundData:
         for idx, agent in enumerate(agents):
             port = 8001 + idx
             # Start server in background - just add & to run in background!
-            self.environment.execute(
-                f"PORT={port} python main.py &", cwd=f"/{agent.name}"
-            )
+            self.environment.execute(f"PORT={port} python main.py &", cwd=f"/{agent.name}")
             cmd.append(f"--url http://0.0.0.0:{port} -n {agent.name}")
 
         time.sleep(3)  # Give servers time to start

codeclash/games/corewar/main.py

@@ -10,9 +10,7 @@ class CoreWarGame(CodeGame):
     name: str = "CoreWar"
 
     def __init__(self, config, *, tournament_id: str, local_output_dir: Path):
-        super().__init__(
-            config, tournament_id=tournament_id, local_output_dir=local_output_dir
-        )
+        super().__init__(config, tournament_id=tournament_id, local_output_dir=local_output_dir)
         self.run_cmd_round: str = "./src/pmars"
         for arg, val in self.game_config.get("args", {}).items():
             if isinstance(val, bool):
@@ -50,9 +48,7 @@ def get_stats(self, result_outputs: list[str], agents: list[Player]) -> RoundSta
             )
         else:
             self.logger.debug("No scores found, returning unknown")
-            return RoundStats(
-                winner="unknown", scores={agent.name: 0 for agent in agents}
-            )
+            return RoundStats(winner="unknown", scores={agent.name: 0 for agent in agents})
 
     def execute_round(self, agents: list[Player]) -> RoundData:
         args = [f"/{agent.name}/warriors/warrior.red" for agent in agents]

codeclash/games/robocode/main.py

@@ -11,9 +11,7 @@ class RoboCodeGame(CodeGame):
     name: str = "RoboCode"
 
     def __init__(self, config, *, tournament_id: str, local_output_dir: Path):
-        super().__init__(
-            config, tournament_id=tournament_id, local_output_dir=local_output_dir
-        )
+        super().__init__(config, tournament_id=tournament_id, local_output_dir=local_output_dir)
         self.run_cmd_round: str = "./robocode.sh"
         for arg, val in self.game_config.get("args", {}).items():
             if isinstance(val, bool):
@@ -73,9 +71,7 @@ def get_stats(self, result_outputs: list[str], agents: list[Player]) -> RoundSta
                 if int(match.group(1)) == 1:
                     winner = player
 
-        return RoundStats(
-            winner=winner, scores=scores, details={"stdout": "\n".join(lines)}
-        )
+        return RoundStats(winner=winner, scores=scores, details={"stdout": "\n".join(lines)})
 
     def execute_round(self, agents: list[Player]) -> RoundData:
         for agent in agents:
@@ -96,9 +92,7 @@ def execute_round(self, agents: list[Player]) -> RoundData:
 {self._get_battle_config()}
 robocode.battle.selectedRobots={selected_robots}
 """
-        create_file_in_container(
-            self.environment, content=battle_content, dest_path=f"battles/{battle_file}"
-        )
+        create_file_in_container(self.environment, content=battle_content, dest_path=f"battles/{battle_file}")
 
         # Run battle with results output to file
         results_file = f"results_{int(time.time())}.txt"