Compare lead change rates between 2-player and multi-player tournaments.

Compare winner's share between 2-player and multi-player tournaments.

Create following data structure per tournament: "player": { "tournament": { "a.py": [(round_num, operation, added, remov

Build a Docker image for the game using the Dockerfile in the codebase. If running in AWS, pull the image from the AWS Docker registr

Calculate what % of modifications happen on the top 10% most-modified files.

Calculate cumulative total number of created files per player per round.

Calculate total file counts by extension at a specific round.

Calculate what percentage of created files are later modified/referenced in subsequent rounds. For each file created in round X, check if it was

Calculate ratio of files with shared prefixes (potential duplicates).

Calculate recovery times for each error in the sequence. For each failed command (returncode != 0), count how many steps it takes to get

Calculate filename redundancy at each round for a single player-tournament. Args: file_history: dict mapping filenames to [(round, op, ad

Calculate comeback and falldown probabilities after i consecutive losses/wins.

Calculate survival curve data from recovery times. Returns the probability that recovery takes MORE than X steps for each X. This is mor

Calculate total created files at a specific round for each player-tournament.

Run code evolution analyses.

Calculate win rate change from normal to transparent for each model

Aggregate consistency data by model and round. For each model at each round, compute mean similarity across all matchups.

Build matrix showing how each model's consistency varies by opponent. Returns (model_list, opponent_matrix) where opponent_matrix[model][oppo

Compute pairwise similarity between a model's solutions at a specific round across multiple games. Use this for both questions 1a (early roun

Copy a file or directory from a Docker container to the local filesystem. The copy operation is recursive for directories. Be extremely

Copy logs from the game's environment to the local machine.

Create line chart visualization of round-to-round recovery rates. Args: success_rates: Dictionary of recovery rates by model and def

Create combined horizontal bar chart showing Elo ratings for all games. All games share the same y-axis ordered by the "ALL" game Elo ratings

Create validation plots showing log-likelihood profiles for each player. Args: output_dir: Directory to save PDF plots

Save metadata and clean up resources.

Save output files, clean up game resources and push agents if requested.

Clean up game resources.

Evaluate the agent's performance by calculating the matrix of every round against each other.

Evaluate vs matrix between the two players.

Extract sequence of command execution results from a trajectory. Returns a list of tuples: (command_type, returncode) in chronological order

Extract all bash commands from a trajectory file. Parses assistant messages to find bash code blocks and extracts the first word of each

Extract modified file paths from a git diff. Args: diff: Git diff text Returns: List of file paths that were modified

Extract round number from trajectory filename like player_r1.traj.json.

Return number of words in THOUGHT section of message content, or None if not found.

Filter out player-tournament trajectories above the player's 99th percentile. Uses the maximum cumulative total per player-tournament to compute

Find all metadata.json files in the log folder.

Format job data for display in the UI

A single per-tick snapshot: tick, units, and world entities.

Serialize per-unit state for one tick: id / owner / coordinates / hp.

Static-friendly game viewer route using path parameters

Returns all actions from a trajectory

Create an agent with environment and game context.

Extract detailed agent information from metadata

Get list of available trajectory files as (player_name, round_num) tuples using metadata

Returns a dictionary of AWS metadata.

Get all jobs formatted for display Args: limit: Maximum number of jobs to return hours_back: Number of hours to look

Get all log folders matching the specified model(s) and arena(s).

Get previous and next game folders for navigation

Return a bootstrap-resampled win matrix with the same format as win_matrix. Sampling is done with replacement over per-tournament contributio

Get normalized scores for all rounds where all players had valid submissions. Returns a tuple of (game_name, game_to_scores, model_to_scores).

Return a parametric bootstrap sample based on the fitted Bradley-Terry model. Uses the fitted strengths to compute win probabilities P(i beat

Static method to get value from any dictionary using dot notation

Get the win counts (rounds won) for all players in a tournament. Returns a tuple of (game_name, game_to_wins, model_to_wins). Only returns da

Extract submission-relevant code diff for a player at a specific round.

Extract submission diffs for a player at a specific round across multiple tournaments.

Return 'white' for dark backgrounds, 'black' for light backgrounds.

Get total number of vCPUs currently allocated in the compute environment

Resolve tournament winner using per_tournament_boolean_drop_draws logic. Returns a dict mapping model_name -> (won_tournament, rounds_won). S

Identify situations where a player lost a round and track if they won the next round. Deficit is calculated per-round as: (winner_score - lo

* Initialize the analysis functionality