kaggle-environments 1.23.3__py3-none-any.whl → 1.23.4__py3-none-any.whl

kaggle_environments/envs/werewolf/scripts/run_pairwise_matrix.py

@@ -0,0 +1,222 @@
+"""Run pairwise zero-sum setting where one player play the entire team of Werewolf and another player play
+the team of Villager. Given a config, we play all possible pairwise combinations N times.
+"""
+
+import argparse
+import logging
+import math
+import multiprocessing
+import os
+import random
+from copy import deepcopy
+from typing import List
+
+import tenacity
+import yaml
+from tqdm import tqdm
+
+from kaggle_environments.envs.werewolf.game.consts import RoleConst
+from kaggle_environments.envs.werewolf.runner import LogExecutionTime, append_timestamp_to_dir, setup_logger
+from kaggle_environments.envs.werewolf.scripts.utils import run_single_game_cli
+
+# Initialize a placeholder logger
+logger = logging.getLogger(__name__)
+
+
+def load_config(config_path):
+    """Loads the configuration from a YAML file."""
+    with open(config_path, "r") as f:
+        return yaml.safe_load(f)
+
+
+def get_team_roles(base_roles: List[str]) -> (List[str], List[str]):
+    """Partitions roles into villager and werewolf teams."""
+    villager_roles = []
+    werewolf_roles = []
+    for role_name in base_roles:
+        role = RoleConst(role_name)
+        if role == RoleConst.WEREWOLF:
+            werewolf_roles.append(role_name)
+        else:
+            villager_roles.append(role_name)
+    return villager_roles, werewolf_roles
+
+
+run_single_game_with_retry = tenacity.retry(
+    wait=tenacity.wait_exponential(multiplier=1, min=2, max=10),
+    stop=tenacity.stop_after_attempt(3),
+    before_sleep=tenacity.before_sleep_log(logger, logging.INFO),
+)(run_single_game_cli)
+
+
+def game_runner_wrapper(args):
+    """Wrapper to unpack arguments for the multiprocessing pool."""
+    game_dir, game_config, use_random_agents, debug, _, _ = args
+    run_single_game_with_retry(game_dir, game_config, use_random_agents, debug)
+
+
+def assign_roles_dup_agents(roles, agent_config, player_ids):
+    agents = [deepcopy(agent_config) for _ in range(len(roles))]
+    for role, agent, player_id in zip(roles, agents, player_ids):
+        agent["role"] = role
+        agent["id"] = player_id
+    return agents
+
+
+def prepare_pairwise_agents(villager_roles, werewolf_roles, player_a_config, player_b_config, player_ids):
+    pid_v, pid_w = player_ids[: len(villager_roles)], player_ids[len(villager_roles) :]
+    agents_v = assign_roles_dup_agents(villager_roles, player_a_config, pid_v)
+    agents_w = assign_roles_dup_agents(werewolf_roles, player_b_config, pid_w)
+    agents = agents_v + agents_w
+    return agents
+
+
+def generate_game_tasks(output_dir, num_tournaments, config, use_random_agents, debug):
+    """
+    Generates game configurations for a pairwise matrix tournament.
+    """
+    base_game_config = config["game_config"]
+    all_players = base_game_config["agents"]
+    num_players = len(all_players)
+    base_roles = [agent["role"] for agent in all_players]
+    player_ids = [agent["id"] for agent in all_players]
+
+    villager_roles, werewolf_roles = get_team_roles(base_roles)
+
+    if not werewolf_roles:
+        raise ValueError("Configuration must include at least one werewolf role.")
+    if not villager_roles:
+        raise ValueError("Configuration must include at least one villager role.")
+
+    for tourney_idx in range(num_tournaments):
+        for i in range(num_players):
+            for j in range(num_players):
+                game_dir = os.path.join(output_dir, f"tourney_{tourney_idx}", f"game_{i}_vs_{j}")
+                os.makedirs(game_dir, exist_ok=True)
+
+                player_a_config = all_players[i]
+                player_b_config = all_players[j]
+
+                game_agents_config = prepare_pairwise_agents(
+                    villager_roles, werewolf_roles, player_a_config, player_b_config, player_ids
+                )
+
+                # since name has to be unique and all names come from config, we by default shuffle all names
+                # since name might change
+                random.shuffle(player_ids)
+                for agent_ind, agent in enumerate(game_agents_config):
+                    agent["id"] = player_ids[agent_ind]
+
+                random.shuffle(game_agents_config)
+
+                game_config = {**base_game_config, "agents": game_agents_config}
+                yield game_dir, game_config, use_random_agents, debug, tourney_idx, f"{i}_vs_{j}"
+
+
+def run_tournament(output_dir, num_tournaments, config, use_random_agents, debug, parallel, num_processes):
+    """
+    Runs a tournament by generating all game tasks and processing them,
+    potentially in parallel.
+    """
+    total_games = num_tournaments * len(config["game_config"]["agents"]) ** 2
+
+    if parallel:
+        logger.info(f"Running games in parallel with up to {num_processes} processes.")
+
+    game_tasks = generate_game_tasks(output_dir, num_tournaments, config, use_random_agents, debug)
+
+    # the following shuffle is to reduce the load of a particular LLM api
+    game_tasks = [*game_tasks]
+    random.shuffle(game_tasks)
+
+    with tqdm(total=total_games, desc="Processing Games") as pbar:
+        if parallel:
+            with multiprocessing.Pool(processes=num_processes) as pool:
+                for _ in pool.imap_unordered(game_runner_wrapper, game_tasks):
+                    pbar.update(1)
+        else:
+            for task_args in game_tasks:
+                game_runner_wrapper(task_args)
+                pbar.update(1)
+
+    logger.info("All game tasks have been processed.")
+
+
+def main():
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    default_config_path = os.path.join(script_dir, "configs", "run", "run_config.yaml")
+
+    parser = argparse.ArgumentParser(description="Run a pairwise matrix tournament for the Werewolf game.")
+    parser.add_argument(
+        "-o",
+        "--output_dir",
+        type=str,
+        help="Output directory for game replays and logs.",
+        default="werewolf_pairwise_matrix",
+    )
+    parser.add_argument(
+        "-c", "--config", type=str, default=default_config_path, help="Path to the base configuration YAML file."
+    )
+    parser.add_argument(
+        "-t",
+        "--num_tournaments",
+        type=int,
+        default=1,
+        help="Number of tournaments to run. Each tournament is a full N*N matrix of games.",
+    )
+    parser.add_argument(
+        "-r", "--use_random_agents", action="store_true", help="Use random agents for all players for fast testing."
+    )
+    parser.add_argument(
+        "-d",
+        "--debug",
+        action="store_true",
+        help="Enable debug mode for the game environment. Forces sequential execution.",
+    )
+    parser.add_argument("-p", "--parallel", action="store_true", help="Run games in parallel using multiple processes.")
+    parser.add_argument(
+        "-n", "--num_processes", type=int, default=None, help="Number of processes for parallel execution."
+    )
+    parser.add_argument(
+        "-a", "--append_timestamp_to_dir", action="store_true", help="Append a timestamp to the output directory."
+    )
+
+    args = parser.parse_args()
+
+    output_dir = append_timestamp_to_dir(args.output_dir, append=args.append_timestamp_to_dir)
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    setup_logger(output_dir, "run_pairwise_matrix")
+
+    config = load_config(args.config)
+
+    if args.num_processes is None:
+        num_processes = max(1, math.floor(multiprocessing.cpu_count() * 0.8))
+    else:
+        num_processes = args.num_processes
+
+    logger.info("Starting tournament with the following settings:")
+    logger.info(f"Output Directory: {output_dir}")
+    logger.info(f"Number of Tournaments: {args.num_tournaments}")
+    logger.info(f"Parallel Execution: {args.parallel}")
+    if args.parallel:
+        logger.info(f"Number of Processes: {num_processes}")
+    logger.info(f"Debug Mode: {args.debug}")
+    logger.info(f"Use Random Agents: {args.use_random_agents}")
+
+    with LogExecutionTime(logger_obj=logger, task_str="pairwise matrix tournament"):
+        run_tournament(
+            output_dir=output_dir,
+            num_tournaments=args.num_tournaments,
+            config=config,
+            use_random_agents=args.use_random_agents,
+            debug=args.debug,
+            parallel=args.parallel,
+            num_processes=num_processes,
+        )
+    logger.info("Tournament finished successfully.")
+
+
+if __name__ == "__main__":
+    main()

kaggle_environments/envs/werewolf/scripts/self_play.py

@@ -0,0 +1,196 @@
+"""Run the settings in a given config with all agents llm agents by substituting all with a single model.
+This is useful for example to evaluate the game rule balance.
+"""
+
+import argparse
+import copy
+import logging
+import multiprocessing
+import os
+import random
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import tenacity
+import yaml
+from tqdm import tqdm
+
+from kaggle_environments.envs.werewolf.runner import LogExecutionTime, append_timestamp_to_dir, setup_logger
+from kaggle_environments.envs.werewolf.scripts.utils import run_single_game_cli
+
+logger = logging.getLogger(__name__)
+
+
+run_single_game_with_retry = tenacity.retry(
+    wait=tenacity.wait_random_exponential(multiplier=1, min=2, max=10),
+    stop=tenacity.stop_after_attempt(3),
+    before_sleep=tenacity.before_sleep_log(logger, logging.INFO),
+)(run_single_game_cli)
+
+
+def game_runner_wrapper(args):
+    """Wrapper to unpack arguments for the multiprocessing pool."""
+    game_dir, game_config, use_random_agents, debug = args
+    run_single_game_with_retry(game_dir, game_config, use_random_agents, debug)
+
+
+def shuffle_field(agents, field_name):
+    values = [agent[field_name] for agent in agents]
+    random.shuffle(values)
+    for agent, value in zip(agents, values):
+        agent[field_name] = value
+
+
+def run_self_play_games(
+    model_name,
+    thumbnail,
+    output_dir,
+    num_games,
+    config,
+    use_random_agents,
+    debug,
+    parallel,
+    num_processes,
+    shuffle_roles,
+):
+    """
+    Generates and runs game tasks for the self-play experiment.
+    """
+    if debug:
+        logger.warning("Debug mode is enabled. Forcing sequential execution.")
+
+    game_tasks = []
+    base_game_config = config["game_config"]
+
+    # modify the config to use a single model
+    agents = base_game_config["agents"]
+    for agent in agents:
+        agent["thumbnail"] = thumbnail
+        agent["agent_id"] = f"llm/{model_name}"
+        agent["display_name"] = os.path.basename(model_name)
+        agent["llms"][0]["model_name"] = model_name
+
+    for i in range(num_games):
+        game_output_dir = os.path.join(output_dir, f"game_{i}")
+        os.makedirs(game_output_dir, exist_ok=True)
+
+        game_config = copy.deepcopy(base_game_config)
+
+        if shuffle_roles:
+            logger.info(f"Shuffling roles for game {i}")
+            role_configs = [
+                {"role": agent["role"], "role_params": agent.get("role_params", {})} for agent in game_config["agents"]
+            ]
+            random.shuffle(role_configs)
+            for agent, role_config in zip(game_config["agents"], role_configs):
+                agent["role"] = role_config["role"]
+                agent["role_params"] = role_config["role_params"]
+
+        # shuffle player ids
+        logger.info(f"Shuffling player ids for game {i}")
+        shuffle_field(game_config["agents"], "id")
+
+        task = (game_output_dir, game_config, use_random_agents, debug)
+        game_tasks.append(task)
+
+    with tqdm(total=num_games, desc="Running Self-Play Games") as pbar:
+        if parallel:
+            with ThreadPoolExecutor(max_workers=num_processes) as executor:
+                futures = [executor.submit(game_runner_wrapper, task) for task in game_tasks]
+                for future in as_completed(futures):
+                    # You could also add error handling here by checking future.exception()
+                    pbar.update(1)
+        else:
+            for task in game_tasks:
+                game_runner_wrapper(task)
+                pbar.update(1)
+
+
+def main():
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    default_config_path = os.path.join(script_dir, "configs", "run", "roundrobin_discussion_small.yaml")
+
+    parser = argparse.ArgumentParser(description="Run N self-play Werewolf games based on a configuration file.")
+    parser.add_argument(
+        "-c", "--config_path", type=str, default=default_config_path, help="Path to the YAML configuration file."
+    )
+    parser.add_argument(
+        "-o",
+        "--output_dir",
+        type=str,
+        default="werewolf_self_play",
+        help="Output directory for the log and replay files.",
+    )
+    parser.add_argument(
+        "-m",
+        "--model_name",
+        type=str,
+        default="gemini/gemini-2.5-flash",
+        help="The model name by litellm for self play.",
+    )
+    parser.add_argument(
+        "-t",
+        "--thumbnail",
+        type=str,
+        default="https://logos-world.net/wp-content/uploads/2025/01/Google-Gemini-Symbol.png",
+        help="The thumbnail image url.",
+    )
+    parser.add_argument("-n", "--num_games", type=int, default=1, help="Number of self-play games to run.")
+    parser.add_argument("-d", "--debug", action="store_true", help="Enable debug mode.")
+    parser.add_argument(
+        "-r", "--random_agents", action="store_true", help="Use random agents for all players for fast testing."
+    )
+    parser.add_argument(
+        "-a", "--append_timestamp_to_dir", action="store_true", help="Append a timestamp to the output directory."
+    )
+    parser.add_argument(
+        "-s", "--shuffle_roles", action="store_true", help="If provided, shuffle the roles for each game."
+    )
+    parser.add_argument("-p", "--parallel", action="store_true", help="Run games in parallel using multiple processes.")
+    parser.add_argument("--num_processes", type=int, default=None, help="Number of processes for parallel execution.")
+
+    args = parser.parse_args()
+
+    run_output_dir = append_timestamp_to_dir(args.output_dir, append=args.append_timestamp_to_dir)
+    os.makedirs(run_output_dir, exist_ok=True)
+    setup_logger(output_dir=run_output_dir, base_name="self_play")
+
+    with open(args.config_path, "r") as f:
+        config = yaml.safe_load(f)
+
+    num_processes = args.num_processes
+    if args.parallel and num_processes is None:
+        # Default to 4x the number of CPUs for I/O bound tasks
+        num_processes = multiprocessing.cpu_count() * 4
+
+    logger.info("Starting self-play with the following settings:")
+    logger.info(f"Model Name: {args.model_name}")
+    logger.info(f"Thumbnail: {args.thumbnail}")
+    logger.info(f"Output Directory: {run_output_dir}")
+    logger.info(f"Number of Games: {args.num_games}")
+    logger.info(f"Config Path: {args.config_path}")
+    logger.info(f"Parallel Execution: {args.parallel}")
+    if args.parallel:
+        logger.info(f"Number of Processes: {num_processes}")
+    logger.info(f"Debug Mode: {args.debug}")
+    logger.info(f"Use Random Agents: {args.random_agents}")
+    logger.info(f"Shuffle Roles: {args.shuffle_roles}")
+
+    with LogExecutionTime(logger_obj=logger, task_str=f"{args.num_games} self-play games"):
+        run_self_play_games(
+            model_name=args.model_name,
+            thumbnail=args.thumbnail,
+            output_dir=run_output_dir,
+            num_games=args.num_games,
+            config=config,
+            use_random_agents=args.random_agents,
+            debug=args.debug,
+            parallel=args.parallel,
+            num_processes=num_processes,
+            shuffle_roles=args.shuffle_roles,
+        )
+
+    logger.info("Self-play run finished successfully.")
+
+
+if __name__ == "__main__":
+    main()

kaggle_environments/envs/werewolf/scripts/utils.py

@@ -0,0 +1,47 @@
+import logging
+import os
+import subprocess
+import sys
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+
+def run_single_game_cli(game_dir, game_config, use_random_agents, debug):
+    """
+    Sets up and runs a single game instance by calling run.py. Running a separate process has the distinct advantage
+    of an atomic game execution unit, so the logging and dumps including html render and json are cleaner.
+    """
+    out_config = {"game_config": game_config}
+    config_path = os.path.join(game_dir, "config.yaml")
+    with open(config_path, "w") as f:
+        yaml.dump(out_config, f, default_flow_style=False)
+
+    run_py_path = os.path.join(os.path.dirname(__file__), "run.py")
+    cmd = [
+        sys.executable,
+        run_py_path,
+        "--config_path",
+        config_path,
+        "--output_dir",
+        game_dir,
+    ]
+    if use_random_agents:
+        cmd.append("--random_agents")
+    if debug:
+        cmd.append("--debug")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        logger.info(f"Game in {game_dir} completed successfully.")
+        if result.stdout:
+            logger.info(result.stdout)
+        if result.stderr:
+            logger.warning(f"Stderr (non-fatal) from game in {game_dir}: {result.stderr}")
+    except subprocess.CalledProcessError as e:
+        error_message = (
+            f"Error running game in {game_dir}.\nReturn Code: {e.returncode}\nStdout: {e.stdout}\nStderr: {e.stderr}"
+        )
+        logger.error(error_message)
+        raise RuntimeError(error_message) from e

{kaggle_environments-1.23.3.dist-info → kaggle_environments-1.23.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaggle-environments
-Version: 1.23.3
+Version: 1.23.4
 Summary: Kaggle Environments
 Author-email: Kaggle <support@kaggle.com>
 Requires-Python: >=3.10

{kaggle_environments-1.23.3.dist-info → kaggle_environments-1.23.4.dist-info}/RECORD

@@ -188,16 +188,21 @@ kaggle_environments/envs/open_spiel_env/games/connect_four/connect_four_proxy.py
 kaggle_environments/envs/open_spiel_env/games/go/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kaggle_environments/envs/open_spiel_env/games/go/go.js,sha256=SWUPrnQCMBlDjUiKTgVn9LeTUM85YbR10JRrq3ddw14,23751
 kaggle_environments/envs/open_spiel_env/games/go/go_proxy.py,sha256=_b-PTFlN7FUtjSx26ciR6Os4rTop8A6vemF86HMYMO8,3407
-kaggle_environments/envs/open_spiel_env/games/repeated_poker/repeated_poker.js,sha256=zNM_NpmPR453aufRKpfsuvpCFYw30C7fgULV6LUf3S4,35306
+kaggle_environments/envs/open_spiel_env/games/repeated_poker/repeated_poker.js,sha256=a2DJk6SrKCU_j3cvTk_eaIIWhyCIdg4r5fqYLzFMP4o,35306
 kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/index.html,sha256=9BsANJfu4GHJhJbtwPGGyF8vjLpYryYvj5NtghwSRzU,372
 kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/package.json,sha256=wB7388yBrChi5rrP2bIUguAgYL_YJ-a9LqZD5lu4Pcs,536
 kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/tsconfig.json,sha256=3X9dsQOgFw_cZ_uXByZIsGrQ5jhFfAZZL7QC6ApJWak,133
 kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/vite.config.ts,sha256=KhIjUn0WWhaoQzQ5YKuWjNndimRF0kFlYDgEnZ0cg7U,208
 kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/replays/test-replay.json,sha256=jf4ilR6SmOYPNohkIGJvmKP5Gju5FY6sfSStX1qtFZg,28919900
 kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/main.ts,sha256=5NZlic4P9aSdMJpWxckaDrObEx2OJj8FNG49g-Z9_ow,1095
-kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/repeated_poker_renderer.js,sha256=XMyktKkyUTF_UXnMn8LerO_rx3YH6nm0omb7ImuLm4M,21092
-kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/components/getRepeatedPokerStateForStep.js,sha256=qzUIlL33-YDpeINi-pCUVLrG1IbVRZuR9h_FVQW3mQ8,9086
+kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/repeated_poker_renderer.js,sha256=ZTaeLtDKqY8qrnxB3KshJVNfWRjo21e1vLcIRXlYkSI,26456
+kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/components/getRepeatedPokerStateForStep.js,sha256=vSVJsKyrWEHEJuZ5ESYXtHfhSZ60IgEC4eenf2w7ZDc,9139
 kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/components/utils.js,sha256=pXDAu4V2OppRCvMdJKQ56q1uFTJReMPIvBL6gwxIJoI,5734
+kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/images/poker_chip_1.svg,sha256=v9yCvpnaQAg8OSUJdJ5PhuTHm9_zXnww-9_7oR_DJpc,22160
+kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/images/poker_chip_10.svg,sha256=z3CP2h5eUGlgBdqNoWGcioekAyPgiuzhyRNr-nbutOE,22160
+kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/images/poker_chip_100.svg,sha256=y4T3Dolr1ZH7HPlTK8B_0SOJO_cDr9HzyqWMuyS7Q-s,63077
+kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/images/poker_chip_25.svg,sha256=oaxCKGaeSZ-LklQ6PRv5OS9wz-tfuvJ2BX4uT15KNEo,22160
+kaggle_environments/envs/open_spiel_env/games/repeated_poker/visualizer/default/src/images/poker_chip_5.svg,sha256=KRgV4RAzJD9DJqzNc0wkKqlN6DhJAuEBl919nQMCJhY,22160
 kaggle_environments/envs/open_spiel_env/games/tic_tac_toe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kaggle_environments/envs/open_spiel_env/games/tic_tac_toe/tic_tac_toe.js,sha256=OD7FbhhOqmL8OC7UqPt0S9znwcUY4YTuhRCdsBd3ALE,17339
 kaggle_environments/envs/open_spiel_env/games/tic_tac_toe/tic_tac_toe_proxy.py,sha256=r1A2Yl0vapJRrTEnvwfP9-P-uz_xtyWdWKXGsRXdR4o,2937
@@ -218,7 +223,9 @@ kaggle_environments/envs/tictactoe/tictactoe.js,sha256=NZDT-oSG0a6a-rso9Ldh9qkJw
 kaggle_environments/envs/tictactoe/tictactoe.json,sha256=zMXZ8-fpT7FBhzz2FFBvRLn4XwtngjEqOieMvI6cCj8,1121
 kaggle_environments/envs/tictactoe/tictactoe.py,sha256=uq3sTHWNMg0dxX2v9pTbJAKM7fwerxQt7OQjCX96m-Y,3657
 kaggle_environments/envs/werewolf/GAME_RULE.md,sha256=KagfA21SyAaT4qgcfAcBwsaxU71RUo-6vajCqFe7PbE,3730
+kaggle_environments/envs/werewolf/README.md,sha256=2pQUjBZjTRNJrIAyKT4qvrx3FjzIM4aJtBFDjBrFxQY,9159
 kaggle_environments/envs/werewolf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kaggle_environments/envs/werewolf/runner.py,sha256=grz8y4Sa6Qr4J5uCyjDuErcu6LhscBYMgHz9lMBa0HQ,5005
 kaggle_environments/envs/werewolf/test_werewolf.py,sha256=_tXQ3hxGODIGuNYkl2r06mNGIoAQBLRvf1MYFWabmmE,4457
 kaggle_environments/envs/werewolf/test_werewolf_deterministic.py,sha256=wj3TzO60msKwuwb8oA0gxENqCA9mdN5rvH8L4xn9sb8,9068
 kaggle_environments/envs/werewolf/werewolf.js,sha256=41MKCrV8tka4z_YwrEdtA7jI-UuISJK8bGaTv2b4bw4,192343
@@ -240,9 +247,40 @@ kaggle_environments/envs/werewolf/game/protocols/bid.py,sha256=ieaL2zxwQiUvRIc78
 kaggle_environments/envs/werewolf/game/protocols/chat.py,sha256=wFewQogic1CHr4AW_tZqvkdF3IiX5ZzCzhyp0tMkcJg,18892
 kaggle_environments/envs/werewolf/game/protocols/factory.py,sha256=hg9Xj5Z-8USmqhouVzo8b7Ktl91xzFsE5_8naD6yErY,2316
 kaggle_environments/envs/werewolf/game/protocols/vote.py,sha256=hKw64ubLMCIAIG5IcmNeV9MPTWWmWpkkCAyia_5kXn0,20716
+kaggle_environments/envs/werewolf/harness/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kaggle_environments/envs/werewolf/harness/base.py,sha256=c3bAJjwJKZmpqE6uZrBy1OkN2REaDDDywW3K9SPBpkw,32194
+kaggle_environments/envs/werewolf/harness/litellm_models.yaml,sha256=58U7eQ5O72cCLTI9Dea-v1tIHSArgOl2IJHQNmrFWtQ,1573
+kaggle_environments/envs/werewolf/harness/test_base.py,sha256=lYxOJrtLX-ttHirtD18sM2XkztH0cRgy69RTFVNZE44,1005
+kaggle_environments/envs/werewolf/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kaggle_environments/envs/werewolf/scripts/add_audio.py,sha256=jFqne5pMPuyrc936AqBn3rWjgFulBnj-V7tc3RL6SDI,18316
+kaggle_environments/envs/werewolf/scripts/measure_cost.py,sha256=_AF0J9BcTtUc_8SgzHk6sdPIHM0v6VFvxKmE677Z6NY,10327
+kaggle_environments/envs/werewolf/scripts/plot_existing_trajectories.py,sha256=VWjN5YhbbbzvmeLZWTt_ZH9InW4I1e8SsfaIPX22X90,5465
+kaggle_environments/envs/werewolf/scripts/rerender_html.py,sha256=QvsOa_FIDK8RgGwVP5AHa8I0DbvhgzhxoQ4z-Q5lbnE,3097
+kaggle_environments/envs/werewolf/scripts/run.py,sha256=WNqdp0Q6nCZPpq6y7UZdHqI28LTPV6BfJ-9v6HWEEKc,3394
+kaggle_environments/envs/werewolf/scripts/run_block.py,sha256=oyaIEMFtQiLzBf4pUUxjmV8f2aLwPXAsz6TIbH9AjKg,8760
+kaggle_environments/envs/werewolf/scripts/run_pairwise_matrix.py,sha256=vUef22sgClpQY_UHuPPXXYMrVO5fUxB8RH5G3-kT3U0,8299
+kaggle_environments/envs/werewolf/scripts/self_play.py,sha256=tVTc_B5VgK4MgQFsyNwzbVKUtluXC15iGdULb4iWSy4,7210
+kaggle_environments/envs/werewolf/scripts/utils.py,sha256=JPLqWaEJRWLhh3x4TyEOsKMuGq1Nvq4vsctG2uDLA74,1574
+kaggle_environments/envs/werewolf/scripts/configs/audio/standard.yaml,sha256=3KbvRfS054CCz8qJqbmi6jH3otq97Wi0BmxJEKesIa8,1211
+kaggle_environments/envs/werewolf/scripts/configs/run/block_basic.yaml,sha256=S0kpIwyVTSVwF9rZMnjbVNXaauZs1rBl0Bq3jMMlBQg,4383
+kaggle_environments/envs/werewolf/scripts/configs/run/comprehensive.yaml,sha256=PrtcvzrIipeHYywFe-ZN0dPr0jZPLMrSvA4ibsTeYpk,3771
+kaggle_environments/envs/werewolf/scripts/configs/run/roundrobin_discussion_DisableDoctorSelfSave_DisableDoctorConsecutiveSave_large.yaml,sha256=7Wm9MUvmZsye2yGLkQarvTEFOXbo3vMtaRncmx0kJkQ,3668
+kaggle_environments/envs/werewolf/scripts/configs/run/roundrobin_discussion_large.yaml,sha256=kv1oM2WCT0aaGmqNSI0p1QUCAIJYZk4GHH1v-0B02V0,3628
+kaggle_environments/envs/werewolf/scripts/configs/run/roundrobin_discussion_small.yaml,sha256=MO3VRvkemPxkifFYuKiq3QkGQ8ePK_1ovsaSrkPH9fU,3666
+kaggle_environments/envs/werewolf/scripts/configs/run/run_config.yaml,sha256=KDlo8slKjUg11a73PsdBliBU8NGh5GzOl5FSTfOVJmk,1590
+kaggle_environments/envs/werewolf/scripts/configs/run/vertex_api_example_config.yaml,sha256=EBYgyXEh8VyxqaBeuKA6SwwanCKPatZPsLaFXbG6VM4,4832
+kaggle_environments/envs/werewolf/scripts/configs/run/rule_experiment/standard.yaml,sha256=MO3VRvkemPxkifFYuKiq3QkGQ8ePK_1ovsaSrkPH9fU,3666
+kaggle_environments/envs/werewolf/scripts/configs/run/rule_experiment/standard_DisableDoctorSelfSave_DisableDoctorConsecutiveSave.yaml,sha256=UKiyNrbXR8QQ0Mf_swe1XDgpCT0vt70Drc9j2Aki1N8,3706
+kaggle_environments/envs/werewolf/scripts/configs/run/rule_experiment/standard_DisableDoctorSelfSave_SeerRevealTeam.yaml,sha256=akqN1D4ta87bovR2f346T8OOcUGZXAk8Jw82Lk7Yp5Y,3715
+kaggle_environments/envs/werewolf/scripts/configs/run/rule_experiment/standard_DisableDoctorSelfSave_SeerRevealTeam_NightEliminationNoReveal_DayExileNoReveal.yaml,sha256=GyqWm9fJ0kQNmKqMN-aYYxOb-g3m0gdgW02ceAr2-GU,3725
+kaggle_environments/envs/werewolf/scripts/configs/run/rule_experiment/standard_DisableDoctorSelfSave_SeerRevealTeam_NightEliminationRevealTeam_DayExileRevealTeam.yaml,sha256=1RmxdyHBliWWeoif0j3h6gROEeGMYYp_7wNGmlQoWCg,3715
+kaggle_environments/envs/werewolf/scripts/configs/run/rule_experiment/standard_disable_doctor_self_save.yaml,sha256=U8IvlC0CiwnT1nhqPQZ_SmRjmVehVuzPUclbe6FBLrw,3667
+kaggle_environments/envs/werewolf/scripts/configs/run/rule_experiment/standard_parallel_voting.yaml,sha256=jcfXR3L0cRRSgkbLMZk3KNCPIcvc3jut_nEkc-rlSyA,3658
+kaggle_environments/envs/werewolf/scripts/configs/run/rule_experiment/standard_parallel_voting_no_tie_exile.yaml,sha256=sfSFlFU4F7doZ-wXUWBl-JgJtmpjrLR-SpCAqKnUYeQ,3662
+kaggle_environments/envs/werewolf/scripts/configs/run/rule_experiment/standard_parallel_voting_roundbiddiscussion.yaml,sha256=UGSLfOhmC-4pRqWsJvOtZRU0YLUuOMAGeEHtxTf3wf8,3710
 kaggle_environments/static/player.html,sha256=Icl5yYscPe4BRoWt0HLOSRJWnznQq2MdTHHCaC2OrQQ,27753
-kaggle_environments-1.23.3.dist-info/entry_points.txt,sha256=h03sq76TdcHvXKcsre1Qm3lIni9dkWehu61xJqI-p8k,69
-kaggle_environments-1.23.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-kaggle_environments-1.23.3.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-kaggle_environments-1.23.3.dist-info/METADATA,sha256=ZB40jlDxGCqUGoIwxNg8cRDdu2Ombdus7v9uw7BfV6A,916
-kaggle_environments-1.23.3.dist-info/RECORD,,
+kaggle_environments-1.23.4.dist-info/entry_points.txt,sha256=h03sq76TdcHvXKcsre1Qm3lIni9dkWehu61xJqI-p8k,69
+kaggle_environments-1.23.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+kaggle_environments-1.23.4.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+kaggle_environments-1.23.4.dist-info/METADATA,sha256=g4GU2wwJIRPurJ62IXhZLMdwgQ53gucCZYUTQOZLQc0,916
+kaggle_environments-1.23.4.dist-info/RECORD,,