Return a backup filename from given filename (given filename with a special suffix).

Return a filtered dict of whole message history for given game role.

Return smallest key greater then given key, or None if not exists.

Generate addresses (couples [power name, token]) of user controlling given power name.

Return greatest key lower than given key, or None if not exists.

Returns user linked to username

Return True if all controlled non-eliminated powers have voted YES to draw game at current phase.

Return True if game has given player token.

Initialize the analyzer with game data and model client

(Network Method) Return True if this power is controlled by given username.

Indicates if the power is a dummy :return: Boolean flag to indicate if the power is a dummy

Check if actual state matches saved fixed state, if game is used as context of a with-block. :param log_error: Boolean that indicates to

Makes sure items() values are priority values instead of heap entries.

Return a game matching given game ID from server database. Raise an exception if such game does not exists. If such game is

Make conversation data from diplomacy game logs. Args: country_to_model: A Series mapping country names to model names l

Makes a dataframe with a row for each order given by every power, in every phase (see module docstring for more details). Args:

takes country-to-model mapping, game state (lmvs_data), conversations, and orders, and returns a dataframe with one row per (power, phase).

Move to next expected phase.

Create a system message (immediately dated) to be sent by server and add it to message history. To be used only by server game.

Notify all game tokens about a game phase update (game processing). :param server_game: game to notify :param previous_phase

Notify all game tokens about current game status. :param server_game: game to notify :type server_game: diplomacy.server.ser

Notify all power tokens about new wait flag for given power. :param server_game: game to notify :param power: power to notif

Completely recalculate the Zobrist hash :return: The updated hash value

Remove game instance associated to given game role.

Disconnect given token from related user and loaded games. Stop related games if needed, e.g. if a game does not have anymore expected nu

Add a game to scheduler only if game has a deadline and is not already scheduled. To add games without deadline, use force_game_processin

Send a request. :param request: request object. :param for_game: (optional) NetworkGame object (required for game requests).

Allows updating the system prompt after initialization.

Simplifies and optimizes SVG content by: 1. Removing unnecessary metadata, comments, and hidden elements. 2. Simplifying paths and shapes

* Sort the table by the specified column

Start given server game. :param server_game: server game :type server_game: ServerGame

Start a new DAIDE TCP server to handle DAIDE clients connections :param game_id: game id to pass to the DAIDE server :param

Returning the string representation of the response

* Toggles the debug panel expansion

* Updates the phase options in the select dropdown

Build a MapError :param code: int code of the error :param message: human readable string message associated to the error

New function - Retrieving object from cache if possible :param name: Name of the map to load :param use_cache: Boolean flag

Adds an order for a power :param power: The power instance issuing the order :param word: The order (e.g. ['A', 'PAR', '-', '

Adds a unit to the map :param xml_map: The xml map being generated :param unit: The unit to add (e.g. 'A PAR') :

Return *every* order of the form 'A/F XYZ S <mover> - <dest>' issued by our other units. Order of return is input order.

Return every order of the form 'A/F XYZ S <holder>' that supports <holder> to HOLD, excluding the holding unit itself.

Build the list of notifications corresponding to an active game state :param current_phase: the current phase :param powers: the lis

Build the list of notifications corresponding to a completed game state :param server_users: the instance of `diplomacy.server.users` of the

Builds the unit_owner cache

Calculate similarity between two relationship dictionaries.

Calculates the score to determine win for each power :return: A dict containing the score for each power (e.g. {'FRANCE': 10, 'ENGLAND':

Determines convoy disruptions. :param may_convoy: Contains the dictionary of all convoys that have a chance to succeed (

Clean common JSON formatting issues from LLM responses.

Clear all game history fields.

Create (force) a tornado websocket connection. Try NB_CONNECTION_ATTEMPTS attempts, waiting for ATTEMPT_DELAY_SECONDS seconds between 2 a

Paradox detection algorithm. Start at starting node and move chain to see if node if performing paradox action :param starti

Indicates that a game is finished and has been won by 'victors' :param victors: The list of victors (e.g. ['FRANCE', 'GERMANY'])

Return supports (from any of our units) that aid <target_order>.

Produce the <Territory …> blocks *exactly* as before for movement phases.

Get the model used for a specific power.

Get the phase data for the phase before the current one.

Return path to server data file name (server.json, making sure that data folder exists. Raises an exception if data folder does not exist

Check if status indicates failure.

Check if status indicates success.

Issues a move order :param xml_map: The xml map being generated :param src_loc: The location where the unit is moving from (

Load CSV file as list of dictionaries.

Return a DataFrame with one row per (game_id, power_name) containing all numeric columns from *_game_analysis.csv plus these derived columns:

Moves to the map's start phase :return: Nothing, but sets the self.phase and self.phase_type settings