Merge branch 'main' into john/robocode-ladder

Author: john-b-yang

codeclash/cli/ladder.py

@@ -1,86 +1,17 @@
-"""`codeclash ladder` subcommands: build a ladder (make) and climb it (run)."""
+"""`codeclash ladder` subcommands: build a ladder (make) and climb it (run).
+
+Thin CLI adapter over :mod:`codeclash.tournaments.ladder`, which holds all ladder logic.
+"""
 
-import copy
-import getpass
-import json
-import time
-from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 
 import typer
 import yaml
 
 from codeclash import CONFIG_DIR
-from codeclash.constants import LOCAL_LOG_DIR
-from codeclash.tournaments.pvp import PvpTournament
-from codeclash.utils.log import get_logger
+from codeclash.tournaments.ladder import LadderTournament, build_ladder, resolve_ladder_rules  # noqa: F401
 from codeclash.utils.yaml_utils import resolve_includes
 
-logger = get_logger("ladder")
-
-
-def _player_slug(branch_init: str) -> str:
-    """Turn a ``human/<author>/<bot>`` init branch into a bare, filesystem-safe player name:
-    strip the ``human/`` prefix and join the rest with ``_`` (e.g. ``human/aleksiy325/snek-two``
-    -> ``aleksiy325_snek-two``).
-
-    RoboCode also uses this name as a Java *package* (``<name>.MyTank``), which must be a bare
-    identifier that does not start with the engine's reserved ``robocode`` namespace. The RoboCode
-    ladder branches are named so the plain slug already satisfies that (``human/robo_code/walls``
-    -> ``robo_code__walls``), so no game-specific handling is needed here.
-    """
-    return branch_init.replace("human/", "").replace("/", "__")
-
-
-def _resolve_ladder_rules(ladder_rules: dict, rounds: int) -> tuple[int, int]:
-    """Validate the required ``ladder_rules`` block and return ``(min_round_wins, win_last_k)``.
-
-    Both keys must be specified explicitly in the config (no defaults):
-    - ``min_round_wins``: the whole number of *agent* rounds the player must win to advance
-      (a ``>=`` threshold). Must be ``1 <= min_round_wins <= rounds``.
-    - ``win_last_k``: the player must win the last ``win_last_k`` round(s). ``1`` means just the final
-      round; ``0`` disables the trailing-rounds requirement entirely. Must be ``<= min_round_wins``.
-
-    The baseline round 0 (identical, un-edited codebases) is excluded from the count — it reflects
-    game variance, not the agent — so wins are counted over the ``rounds`` rounds the agent actually
-    edits (rounds 1..``rounds``).
-    """
-    if "min_round_wins" not in ladder_rules:
-        typer.echo("ladder_rules.min_round_wins is required; specify it explicitly in the config.")
-        raise typer.Exit(1)
-    if "win_last_k" not in ladder_rules:
-        typer.echo("ladder_rules.win_last_k is required; specify it explicitly in the config.")
-        raise typer.Exit(1)
-    min_round_wins = ladder_rules["min_round_wins"]
-    win_last_k = ladder_rules["win_last_k"]
-
-    # min_round_wins: whole number of agent rounds the player must win (round 0 excluded).
-    if isinstance(min_round_wins, bool) or not isinstance(min_round_wins, int):
-        typer.echo(f"ladder_rules.min_round_wins must be an integer, got {min_round_wins!r}.")
-        raise typer.Exit(1)
-    if not 1 <= min_round_wins <= rounds:
-        typer.echo(f"ladder_rules.min_round_wins must be in [1, {rounds}] (tournament.rounds), got {min_round_wins}.")
-        raise typer.Exit(1)
-
-    # win_last_k: number of trailing rounds the player must win (1 == just the final round, 0 == disabled).
-    if isinstance(win_last_k, bool) or not isinstance(win_last_k, int):
-        typer.echo(f"ladder_rules.win_last_k must be an integer, got {win_last_k!r}.")
-        raise typer.Exit(1)
-    if win_last_k < 0:
-        typer.echo(
-            f"ladder_rules.win_last_k must be >= 0, got {win_last_k}. "
-            "Use 0 to disable the trailing-rounds requirement, or 1 to require winning only the final round."
-        )
-        raise typer.Exit(1)
-    if win_last_k > min_round_wins:
-        typer.echo(
-            f"ladder_rules.win_last_k ({win_last_k}) cannot exceed ladder_rules.min_round_wins ({min_round_wins})."
-        )
-        raise typer.Exit(1)
-
-    return min_round_wins, win_last_k
-
-
 ladder_app = typer.Typer(
     no_args_is_help=True,
     add_completion=False,
@@ -89,6 +20,12 @@ def _resolve_ladder_rules(ladder_rules: dict, rounds: int) -> tuple[int, int]:
 )
 
 
+def _load_config(config_path: Path) -> dict:
+    yaml_content = config_path.read_text()
+    preprocessed_yaml = resolve_includes(yaml_content, base_dir=CONFIG_DIR)
+    return yaml.safe_load(preprocessed_yaml)
+
+
 @ladder_app.command("make")
 def make(
     config_path: Path = typer.Argument(..., help="Path to the ladder (round-robin) config file."),
@@ -100,46 +37,7 @@ def make(
 
     [dim]• codeclash ladder make configs/ladder/make_battlesnake.yaml[/dim]
     """
-    yaml_content = config_path.read_text()
-    preprocessed_yaml = resolve_includes(yaml_content, base_dir=CONFIG_DIR)
-    config = yaml.safe_load(preprocessed_yaml)
-
-    players = config["players"]
-    num_players = len(players)
-
-    # Build one fully independent (deep-copied) config per pair up front so concurrent runs
-    # never share or mutate the same player/config dicts.
-    jobs: list[tuple[dict, Path]] = []
-    for i in range(num_players):
-        for j in range(i + 1, num_players):
-            player1 = copy.deepcopy(players[i])
-            player1["name"] = _player_slug(player1["branch_init"])
-            player2 = copy.deepcopy(players[j])
-            player2["name"] = _player_slug(player2["branch_init"])
-            pvp_config = {**copy.deepcopy(config), "players": [player1, player2]}
-            vs = f"PvpTournament.{player1['name']}_vs_{player2['name']}".replace("/", "_")
-            output_dir = LOCAL_LOG_DIR / "ladder" / config["game"]["name"] / vs
-            jobs.append((pvp_config, output_dir))
-
-    def run_pair(pvp_config: dict, output_dir: Path) -> None:
-        try:
-            tournament = PvpTournament(pvp_config, output_dir=output_dir)
-        except FileExistsError:
-            return  # already completed by a previous invocation
-        # A single failing pair must not abort the rest of a long round-robin.
-        try:
-            tournament.run()
-        except Exception:
-            logger.exception(f"Pair failed, skipping: {output_dir.name}")
-
-    if workers <= 1:
-        for pvp_config, output_dir in jobs:
-            run_pair(pvp_config, output_dir)
-    else:
-        with ThreadPoolExecutor(max_workers=workers) as executor:
-            futures = [executor.submit(run_pair, c, d) for c, d in jobs]
-            for f in as_completed(futures):
-                f.result()
+    build_ladder(_load_config(config_path), workers=workers)
 
 
 @ladder_app.command("run")
@@ -156,124 +54,16 @@ def run(
 
     [dim]• codeclash ladder run path/to/ladder_config.yaml -c  # clean up after each rung[/dim]
     """
-    yaml_content = config_path.read_text()
-    preprocessed_yaml = resolve_includes(yaml_content, base_dir=CONFIG_DIR)
-    config = yaml.safe_load(preprocessed_yaml)
-    ladder, player, rounds, sims = (
-        config["ladder"],
-        config["player"],
-        config["tournament"]["rounds"],
-        config["game"]["sims_per_round"],
-    )
-    min_round_wins, win_last_k = _resolve_ladder_rules(config.get("ladder_rules", {}), rounds)
-    timestamp = time.strftime("%y%m%d%H%M%S")
-    del config["player"]
-    del config["ladder"]
-    config.pop("ladder_rules", None)
-
-    last_k_rule = "disabled" if win_last_k == 0 else f"win the last {win_last_k} round(s)"
-    advancement_rule = (
-        f"Ladder advancement rule: win >= {min_round_wins} of {rounds} agent rounds "
-        f"(baseline round 0 excluded) and {last_k_rule}."
-    )
-    print(advancement_rule)
-    logger.info(advancement_rule)
-    ladder_folder = f"LadderTournament.{config['game']['name']}.r{rounds}.s{sims}.{player['name']}.{timestamp}"
-    player["branch"] = ladder_folder
-    parent_dir = LOCAL_LOG_DIR / getpass.getuser() / ladder_folder
-
-    rungs_cleared = 0
-    advanced = False
-    for idx, opponent in enumerate(ladder):
-        opponent_rank = len(ladder) - idx
-        opponent["name"] = _player_slug(opponent["branch_init"])
-        if "branch_init" in player and idx > 0:
-            # After first opponent, remove branch_init so that player continues from previous tournament's codebase
-            del player["branch_init"]
-        c = {
-            **config,
-            "players": [
-                player,
-                opponent,
-            ],
-        }
-
-        players = [p["name"] for p in c["players"]]
-        p_num = len(players)
-        p_list = ".".join(players)
-        suffix_part = f".{suffix}" if suffix else ""
-        folder_name = f"PvpTournament.{c['game']['name']}.r{rounds}.s{sims}.p{p_num}.{p_list}{suffix_part}"
-
-        tournament_dir = parent_dir / folder_name if output_dir is None else output_dir / folder_name
-        tournament = PvpTournament(
-            c,
-            output_dir=tournament_dir,
+    config = _load_config(config_path)
+    try:
+        tournament = LadderTournament(
+            config,
+            output_dir=output_dir,
+            suffix=suffix,
             cleanup=cleanup,
             keep_containers=keep_containers,
         )
-        tournament.run()
-
-        # Get results
-        metadata_path = tournament_dir / "metadata.json"
-        with open(metadata_path) as f:
-            metadata = yaml.safe_load(f)
-        round_winners = [r["winner"] for k, r in metadata["round_stats"].items() if int(k) != 0]
-
-        # Advancement rule (required via `ladder_rules`): win at least `min_round_wins` of the
-        # agent rounds AND win the last `win_last_k` rounds. win_last_k == 0 disables the
-        # trailing-rounds requirement.
-        player_wins = sum(1 for w in round_winners if w == player["name"])
-        won_majority = player_wins >= min_round_wins
-        won_last_k = win_last_k == 0 or all(w == player["name"] for w in round_winners[-win_last_k:])
-        advanced = won_majority and won_last_k
-
-        # Record this rung's outcome in its metadata.json (durable gameplay log). The rule itself
-        # (min_round_wins, win_last_k) is constant across the run and lives in the ladder summary.
-        metadata["ladder_advancement"] = {
-            "player_wins": player_wins,
-            "won_last_k": won_last_k,
-            "cleared": advanced,
-        }
-        with open(metadata_path, "w") as f:
-            json.dump(metadata, f, indent=2)
-
-        if not advanced:
-            # Player failed the advancement rule; the ladder challenge ends here.
-            print("=" * 10)
-            print(
-                f"{player['name']} did not clear {opponent['name']} "
-                f"(rank {opponent_rank}/{len(ladder)}): won {player_wins}/{len(round_winners)} agent rounds "
-                f"(needed >= {min_round_wins}), last {win_last_k} round(s) won: {won_last_k}.\n"
-                "Ladder challenge ends."
-            )
-            print("=" * 10)
-            break
-
-        rungs_cleared += 1
-        print("=" * 10)
-        print(
-            f"{player['name']} successfully beat {opponent['name']} (rank {opponent_rank}/{len(ladder)}) "
-            f"in {player_wins}/{len(round_winners)} rounds.\n"
-            "Ladder challenge continuing"
-        )
-        print("=" * 10)
-
-    # Persist the overall climb result to a ladder-level metadata.json in the run's parent dir.
-    ladder_summary = {
-        "player": player["name"],
-        "game": config["game"]["name"],
-        "rounds": rounds,
-        "min_round_wins": min_round_wins,
-        "win_last_k": win_last_k,
-        "ladder_size": len(ladder),
-        "rungs_cleared": rungs_cleared,
-        "final_opponent": opponent["name"],
-        "final_opponent_rank": opponent_rank,
-        "cleared_ladder": rungs_cleared == len(ladder),
-    }
-    parent_dir.mkdir(parents=True, exist_ok=True)
-    with open(parent_dir / "metadata.json", "w") as f:
-        json.dump(ladder_summary, f, indent=2)
-
-    print(f"Ladder tournament complete. Logs saved to {parent_dir}")
-    print(f"Final opponent faced: {opponent['name']} (rank {opponent_rank}/{len(ladder)} in ladder)")
+    except ValueError as e:
+        typer.echo(str(e))
+        raise typer.Exit(1)
+    tournament.run()