class GamePhaseData(Jsonable):
""" Small class to represent data for a game phase:
phase name, state, orders, orders results and messages for this phase.
"""
__slots__ = ['name', 'state', 'orders', 'results', 'messages']
model = {
strings.NAME:
str,
strings.STATE:
dict,
strings.ORDERS:
parsing.DictType(str,
parsing.OptionalValueType(parsing.SequenceType(str))),
strings.RESULTS:
parsing.DictType(
str,
parsing.SequenceType(parsing.StringableType(
common.StringableCode))),
strings.MESSAGES:
MESSAGES_TYPE,
}
def __init__(self, name, state, orders, results, messages):
""" Constructor. """
self.name = ''
self.state = {}
self.orders = {}
self.results = {}
self.messages = {}
super(GamePhaseData, self).__init__(name=name,
state=state,
orders=orders,
results=results,
messages=messages)
def test_dict_type():
""" Test dict type. """
checker = parsing.DictType(str, int)
checker.validate({'test': 1})
assert_raises(lambda: checker.validate({'test': 1.0}),
exceptions.TypeException)
checker = parsing.DictType(MyStringable, float)
checker.validate({MyStringable('12'): 2.5})
assert_raises(lambda: checker.validate({'12': 2.5}),
exceptions.TypeException)
assert_raises(lambda: checker.validate({MyStringable('12'): 2}),
exceptions.TypeException)
checker = parsing.DictType(MyStringable,
float,
dict_builder=SortedDict.builder(
MyStringable, float))
value = {MyStringable(12): 22.0}
checker.validate(value)
updated_value = checker.update(value)
assert isinstance(updated_value, SortedDict)
assert updated_value.key_type is MyStringable
assert updated_value.val_type is float
json_value = {'MyStringable 12': 22.0}
assert checker.to_type(json_value) == SortedDict(
MyStringable, float, {MyStringable('12'): 22.0})
assert checker.to_json(
SortedDict(MyStringable, float,
{MyStringable(12): 22.0})) == json_value
class SetGameState(_AbstractGameRequest):
""" Game request to set a game state (for exper users). Require game master privileges.
:param state: game state
:param orders: dictionary mapping a power name to a list of orders strings
:param results: dictionary mapping a unit to a list of order result strings
:param messages: dictionary mapping a timestamp to a message
:type state: dict
:type orders: dict
:type results: dict
:type messages: dict
:return: None
"""
__slots__ = ['state', 'orders', 'results', 'messages']
params = {
strings.STATE:
dict,
strings.ORDERS:
parsing.DictType(str, parsing.SequenceType(str)),
strings.RESULTS:
parsing.DictType(str, parsing.SequenceType(str)),
strings.MESSAGES:
parsing.DictType(int, parsing.JsonableClassType(Message),
SortedDict.builder(int, Message)),
}
def __init__(self, **kwargs):
self.state = {}
self.orders = {}
self.results = {}
self.messages = {} # type: SortedDict
super(SetGameState, self).__init__(**kwargs)
class PowersControllers(_GameNotification):
""" Notification about current controller for each power in a game. """
__slots__ = ['powers', 'timestamps']
params = {
# {power_name => controller_name}
strings.POWERS:
parsing.DictType(str, parsing.OptionalValueType(str)),
# {power_name => controller timestamp}
strings.TIMESTAMPS:
parsing.DictType(str, int)
}
def __init__(self, **kwargs):
self.powers = {}
self.timestamps = {}
super(PowersControllers, self).__init__(**kwargs)
class MyJsonable(Jsonable):
""" Example of class derived from Jsonable. """
__slots__ = ('field_a', 'field_b', 'field_c', 'field_d', 'field_e',
'field_f', 'field_g')
model = {
'field_a':
bool,
'field_b':
str,
'field_c':
parsing.OptionalValueType(float),
'field_d':
parsing.DefaultValueType(str, 'super'),
'field_e':
parsing.SequenceType(int),
'field_f':
parsing.SequenceType(float, sequence_builder=SortedSet.builder(float)),
'field_g':
parsing.DefaultValueType(
parsing.DictType(str, int, SortedDict.builder(str, int)),
{'x': -1})
}
def __init__(self, **kwargs):
""" Constructor """
self.field_a = None
self.field_b = None
self.field_c = None
self.field_d = None
self.field_e = None
self.field_f = None
self.field_g = {}
super(MyJsonable, self).__init__(**kwargs)
class PowersControllers(_GameNotification):
""" Notification about current controller for each power in a game.
Properties:
- **powers**: A :class:`Dict` that maps a power_name to a controller_name :class:`str`.
- **timestamps**: A :class:`Dict` that maps a power_name to timestamp where the controller took over.
"""
__slots__ = ['powers', 'timestamps']
params = {
# {power_name => controller_name}
strings.POWERS: parsing.DictType(str, parsing.OptionalValueType(str)),
# {power_name => controller timestamp}
strings.TIMESTAMPS: parsing.DictType(str, int)
}
def __init__(self, **kwargs):
self.powers = {}
self.timestamps = {}
super(PowersControllers, self).__init__(**kwargs)
class DataPossibleOrders(_AbstractResponse):
""" Response containing information about possible orders for a game at its current phase.
Properties:
- **possible_orders**: dictionary mapping a location short name to all possible orders here
- **orderable_locations**: dictionary mapping a power name to its orderable locations
"""
__slots__ = ['possible_orders', 'orderable_locations']
params = {
# {location => [orders]}
strings.POSSIBLE_ORDERS:
parsing.DictType(str, parsing.SequenceType(str)),
# {power name => [locations]}
strings.ORDERABLE_LOCATIONS:
parsing.DictType(str, parsing.SequenceType(str)),
}
def __init__(self, **kwargs):
self.possible_orders = {}
self.orderable_locations = {}
super(DataPossibleOrders, self).__init__(**kwargs)
class VoteUpdated(_GameNotification):
""" Notification about votes updated for a game (for omniscient observers). Properties:
- vote: dictionary mapping a power name to a Vote object representing power vote.
"""
__slots__ = ['vote']
params = {
strings.VOTE:
parsing.DictType(str,
parsing.EnumerationType(strings.ALL_VOTE_DECISIONS))
}
def __init__(self, **kwargs):
self.vote = None # type: dict{str, str}
super(VoteUpdated, self).__init__(**kwargs)
class SetGameState(_AbstractGameRequest):
""" Request to set a game state.
Expected response: responses.Ok
Expected response handler result: None
"""
__slots__ = ['state', 'orders', 'results', 'messages']
params = {
strings.STATE:
dict,
strings.ORDERS:
parsing.DictType(str, parsing.SequenceType(str)),
strings.RESULTS:
parsing.DictType(str, parsing.SequenceType(str)),
strings.MESSAGES:
parsing.DictType(int, parsing.JsonableClassType(Message),
SortedDict.builder(int, Message)),
}
def __init__(self, **kwargs):
self.state = {}
self.orders = {}
self.results = {}
self.messages = {} # type: SortedDict
super(SetGameState, self).__init__(**kwargs)
def test_indexed_sequence():
""" Test parser type for dicts stored as sequences. """
checker = parsing.IndexedSequenceType(
parsing.DictType(str, parsing.JsonableClassType(MyJsonable)),
'field_b')
sequence = [
MyJsonable(field_a=True,
field_b='x1',
field_e=[1, 2, 3],
field_f=[1., 2., 3.]),
MyJsonable(field_a=True,
field_b='x3',
field_e=[1, 2, 3],
field_f=[1., 2., 3.]),
MyJsonable(field_a=True,
field_b='x2',
field_e=[1, 2, 3],
field_f=[1., 2., 3.]),
MyJsonable(field_a=True,
field_b='x5',
field_e=[1, 2, 3],
field_f=[1., 2., 3.]),
MyJsonable(field_a=True,
field_b='x4',
field_e=[1, 2, 3],
field_f=[1., 2., 3.])
]
dct = {element.field_b: element for element in sequence}
checker.validate(dct)
checker.update(dct)
jval = checker.to_json(dct)
assert isinstance(jval, list), type(jval)
from_jval = checker.to_type(jval)
assert isinstance(from_jval, dict), type(from_jval)
assert len(dct) == 5
assert len(from_jval) == 5
for key in ('x1', 'x2', 'x3', 'x4', 'x5'):
assert key in dct, (key, list(dct.keys()))
assert key in from_jval, (key, list(from_jval.keys()))
def test_model_parsing():
""" Test parsing for a real model. """
model = {
'name': str,
'language': ('fr', 'en'),
'myjsonable': parsing.JsonableClassType(MyJsonable),
'mydict': parsing.DictType(str, float),
'nothing': (bool, str),
'default_float': parsing.DefaultValueType(float, 33.44),
'optional_float': parsing.OptionalValueType(float)
}
bad_data_field = {
'_name_':
'hello',
'language':
'fr',
'myjsonable':
MyJsonable(field_a=False, field_b='test', field_e={1}, field_f=[6.5]),
'mydict': {
'a': 2.5,
'b': -1.6
},
'nothing':
'thanks'
}
bad_data_type = {
'name':
'hello',
'language':
'fr',
'myjsonable':
MyJsonable(field_a=False, field_b='test', field_e={1}, field_f=[6.5]),
'mydict': {
'a': 2.5,
'b': -1.6
},
'nothing':
2.5
}
bad_data_value = {
'name':
'hello',
'language':
'__',
'myjsonable':
MyJsonable(field_a=False, field_b='test', field_e={1}, field_f=[6.5]),
'mydict': {
'a': 2.5,
'b': -1.6
},
'nothing':
'2.5'
}
good_data = {
'name':
'hello',
'language':
'fr',
'myjsonable':
MyJsonable(field_a=False, field_b='test', field_e={1}, field_f=[6.5]),
'mydict': {
'a': 2.5,
'b': -1.6
},
'nothing':
'2.5'
}
assert_raises(lambda: parsing.validate_data(bad_data_field, model),
(exceptions.TypeException, ))
assert_raises(lambda: parsing.validate_data(bad_data_type, model),
(exceptions.TypeException, ))
assert_raises(lambda: parsing.validate_data(bad_data_value, model),
(exceptions.ValueException, ))
assert 'default_float' not in good_data
assert 'optional_float' not in good_data
parsing.validate_data(good_data, model)
updated_good_data = parsing.update_data(good_data, model)
assert 'default_float' in updated_good_data
assert 'optional_float' in updated_good_data
assert updated_good_data['default_float'] == 33.44
assert updated_good_data['optional_float'] is None
class Power(Jsonable):
""" Power Class
Properties:
- **abbrev** - Contains the abbrev of the power (i.e. the first letter of the power name) (e.g. 'F' for FRANCE)
- **adjust** - List of pending adjustment orders
(e.g. ['A PAR B', 'A PAR R MAR', 'A MAR D', 'WAIVE'])
- **centers** - Contains the list of supply centers currently controlled by the power ['MOS', 'SEV', 'STP']
- **civil_disorder** - Bool flag to indicate that the power has been put in CIVIL_DISORDER (e.g. True or False)
- **controller** - Sorted dictionary mapping timestamp to controller (either dummy or a user ID) who takes
control of power at this timestamp.
- **game** - Contains a reference to the game object
- **goner** - Boolean to indicate that this power doesn't control any SCs any more (e.g. True or False)
- **homes** - Contains a list of homes supply centers (where you can build)
e.g. ['PAR', 'MAR', ... ] or None if empty
- **influence** - Contains a list of locations influenced by this power
Note: To influence a location, the power must have visited it last.
e.g ['PAR', 'MAR', ... ]
- **name** - Contains the name of the power (e.g. 'FRANCE')
- **orders** - Contains a dictionary of units and their orders.
For NO_CHECK games, unit is 'ORDER 1', 'ORDER 2', ...
- e.g. {'A PAR': '- MAR' } or {'ORDER 1': 'A PAR - MAR', 'ORDER 2': '...', ... }
- Can also be {'REORDER 1': 'A PAR - MAR', 'INVALID 1': 'A PAR - MAR', ... } after validation
- **retreats** - Contains the list of units that need to retreat with their possible retreat locations
(e.g. {'A PAR': ['MAR', 'BER']})
- **role** - Power type (observer, omniscient, player or server power).
Either the power name (for a player power) or a value in diplomacy.utils.strings.ALL_ROLE_TYPES
- **tokens** - Only for server power: set of tokens of current power controlled (if not None).
- **units** - Contains the list of units (e.g. ['A PAR', 'A MAR', ...]
- **vote** - Only for omniscient, player and server power: power vote ('yes', 'no' or 'neutral').
"""
__slots__ = [
'game', 'name', 'abbrev', 'adjust', 'centers', 'units', 'influence',
'homes', 'retreats', 'goner', 'civil_disorder', 'orders', 'role',
'controller', 'vote', 'order_is_set', 'wait', 'tokens'
]
model = {
strings.ABBREV:
parsing.OptionalValueType(str),
strings.ADJUST:
parsing.DefaultValueType(parsing.SequenceType(str), []),
strings.CENTERS:
parsing.DefaultValueType(parsing.SequenceType(str), []),
strings.CIVIL_DISORDER:
parsing.DefaultValueType(int, 0),
strings.CONTROLLER:
parsing.DefaultValueType(
parsing.DictType(int, str, SortedDict.builder(int, str)), {}),
strings.HOMES:
parsing.OptionalValueType(parsing.SequenceType(str)),
strings.INFLUENCE:
parsing.DefaultValueType(parsing.SequenceType(str), []),
strings.NAME:
parsing.PrimitiveType(str),
strings.ORDER_IS_SET:
parsing.DefaultValueType(OrderSettings.ALL_SETTINGS,
OrderSettings.ORDER_NOT_SET),
strings.ORDERS:
parsing.DefaultValueType(parsing.DictType(str, str), {}),
strings.RETREATS:
parsing.DefaultValueType(
parsing.DictType(str, parsing.SequenceType(str)), {}),
strings.ROLE:
parsing.DefaultValueType(str, strings.SERVER_TYPE),
strings.TOKENS:
parsing.DefaultValueType(parsing.SequenceType(str, set), ()),
strings.UNITS:
parsing.DefaultValueType(parsing.SequenceType(str), []),
strings.VOTE:
parsing.DefaultValueType(
parsing.EnumerationType(strings.ALL_VOTE_DECISIONS),
strings.NEUTRAL),
strings.WAIT:
parsing.DefaultValueType(bool, True),
}
def __init__(self, game=None, name=None, **kwargs):
""" Constructor """
self.game = game
self.abbrev = None
self.adjust, self.centers, self.units, self.influence = [], [], [], []
self.homes = None
self.retreats = {}
self.goner = self.civil_disorder = 0
self.orders = {}
self.name = ''
self.role = ''
self.controller = SortedDict(int, str)
self.vote = ''
self.order_is_set = 0
self.wait = False
self.tokens = set()
super(Power, self).__init__(name=name, **kwargs)
assert self.role in strings.ALL_ROLE_TYPES or self.role == self.name
if not self.controller:
self.controller.put(common.timestamp_microseconds(), strings.DUMMY)
def __str__(self):
""" Returns a representation of the power instance """
show_cd = self.civil_disorder
show_inhabits = self.homes is not None
show_owns = self.centers
show_retreats = len(self.retreats) > 0
text = ''
text += '\n%s (%s)' % (self.name, self.role)
text += '\nPLAYER %s' % self.controller.last_value()
text += '\nCD' if show_cd else ''
text += '\nINHABITS %s' % ' '.join(self.homes) if show_inhabits else ''
text += '\nOWNS %s' % ' '.join(self.centers) if show_owns else ''
if show_retreats:
text += '\n'.join([''] + [
' '.join([unit, '-->'] + places)
for unit, places in self.retreats.items()
])
text = '\n'.join([text] + self.units + self.adjust)
# Orders - RIO is for REORDER, INVALID, ORDER (in NO_CHECK games)
text_order = '\nORDERS\n'
for unit, order in self.orders.items():
if unit[0] not in 'RIO':
text_order += '%s ' % unit
text_order += order + '\n'
text += text_order if self.orders else ''
return text
def __deepcopy__(self, memo):
""" Fast deep copy implementation (**not setting the game object**) """
cls = self.__class__
result = cls.__new__(cls)
# Deep copying
for key in self.__slots__:
if key not in ['game']:
setattr(result, key, deepcopy(getattr(self, key)))
# Game
setattr(result, 'game', None)
return result
def reinit(self, include_flags=6):
""" Performs a reinitialization of some of the parameters
:param include_flags: Bit mask to indicate which params to reset
(bit 1 = orders, 2 = persistent, 4 = transient)
:return: None
"""
reinit_persistent = include_flags & 2
reinit_transient = include_flags & 4
reinit_orders = include_flags & 1
# Initialize the persistent parameters
if reinit_persistent:
self.abbrev = None
# Initialize the transient parameters
if reinit_transient:
for home in self.homes:
self.game.update_hash(self.name, loc=home, is_home=True)
for center in self.centers:
self.game.update_hash(self.name, loc=center, is_center=True)
for unit in self.units:
self.game.update_hash(self.name,
unit_type=unit[0],
loc=unit[2:])
for dis_unit in self.retreats:
self.game.update_hash(self.name,
unit_type=dis_unit[0],
loc=dis_unit[2:],
is_dislodged=True)
self.homes = None
self.centers, self.units, self.influence = [], [], []
self.retreats = {}
# Initialize the order-related parameters
if reinit_orders:
self.civil_disorder = 0
self.adjust = []
self.orders = {}
if self.is_eliminated():
self.order_is_set = OrderSettings.ORDER_SET_EMPTY
self.wait = False
else:
self.order_is_set = OrderSettings.ORDER_NOT_SET
self.wait = True if self.is_dummy() else (
not self.game.real_time)
self.goner = 0
@staticmethod
def compare(power_1, power_2):
""" Comparator object - Compares two Power objects
:param power_1: The first Power object to compare
:param power_2: The second Power object to compare
:return: 1 if self is greater, -1 if other is greater, 0 if they are equal
"""
cmp = lambda power_1, power_2: ((power_1 > power_2) -
(power_1 < power_2))
xstr = lambda string: string or '' # To avoid comparing with None
cmp_type = cmp(xstr(power_1.role), xstr(power_2.role))
cmp_name = cmp(xstr(power_1.name), xstr(power_2.name))
return cmp_type or cmp_name
def initialize(self, game):
""" Initializes a game and resets home, centers and units
:param game: The game to use for initialization
:type game: diplomacy.Game
"""
# Not initializing observers and monitors
assert self.is_server_power()
self.game = game
self.order_is_set = OrderSettings.ORDER_NOT_SET
self.wait = True if self.is_dummy() else (not self.game.real_time)
# Get power abbreviation.
self.abbrev = self.game.map.abbrev.get(self.name, self.name[0])
# Resets homes
if self.homes is None:
self.homes = []
for home in game.map.homes.get(self.name, []):
self.game.update_hash(self.name, loc=home, is_home=True)
self.homes.append(home)
# Resets the centers and units
if not self.centers:
for center in game.map.centers.get(self.name, []):
game.update_hash(self.name, loc=center, is_center=True)
self.centers.append(center)
if not self.units:
for unit in game.map.units.get(self.name, []):
game.update_hash(self.name, unit_type=unit[0], loc=unit[2:])
self.units.append(unit)
self.influence.append(unit[2:5])
def merge(self, other_power):
""" Transfer all units, centers, and homes of the other_power to this power
:param other_power: The other power (will be empty after the merge)
"""
# Regular units
for unit in list(other_power.units):
self.units.append(unit)
other_power.units.remove(unit)
self.game.update_hash(self.name, unit_type=unit[0], loc=unit[2:])
self.game.update_hash(other_power.name,
unit_type=unit[0],
loc=unit[2:])
# Dislodged units
for unit in list(other_power.retreats.keys()):
self.retreats[unit] = other_power.retreats[unit]
del other_power.retreats[unit]
self.game.update_hash(self.name,
unit_type=unit[0],
loc=unit[2:],
is_dislodged=True)
self.game.update_hash(other_power.name,
unit_type=unit[0],
loc=unit[2:],
is_dislodged=True)
# Influence
for loc in list(other_power.influence):
self.influence.append(loc)
other_power.influence.remove(loc)
# Supply centers
for center in list(other_power.centers):
self.centers.append(center)
other_power.centers.remove(center)
self.game.update_hash(self.name, loc=center, is_center=True)
self.game.update_hash(other_power.name, loc=center, is_center=True)
# Homes
for home in list(other_power.homes):
self.homes.append(home)
other_power.homes.remove(home)
self.game.update_hash(self.name, loc=home, is_home=True)
self.game.update_hash(other_power.name, loc=home, is_home=True)
# Clearing state cache
self.game.clear_cache()
def clear_units(self):
""" Removes all units from the map """
for unit in self.units:
self.game.update_hash(self.name, unit_type=unit[0], loc=unit[2:])
for unit in self.retreats:
self.game.update_hash(self.name,
unit_type=unit[0],
loc=unit[2:],
is_dislodged=True)
self.units = []
self.retreats = {}
self.influence = []
self.game.clear_cache()
def clear_centers(self):
""" Removes ownership of all supply centers """
for center in self.centers:
self.game.update_hash(self.name, loc=center, is_center=True)
self.centers = []
self.game.clear_cache()
def is_dummy(self):
""" Indicates if the power is a dummy
:return: Boolean flag to indicate if the power is a dummy
"""
return self.controller.last_value() == strings.DUMMY
def is_eliminated(self):
""" Returns a flag to show if player is eliminated
:return: If the current power is eliminated
"""
# Not eliminated if has units left
if self.units or self.centers or self.retreats:
return False
return True
def clear_orders(self):
""" Clears the power's orders """
self.reinit(include_flags=1)
def moves_submitted(self):
""" Returns a boolean to indicate if moves has been submitted
:return: 1 if not in Movement phase, or orders submitted, or no more units lefts
"""
if self.game.phase_type != 'M':
return 1
return self.orders or not self.units
# ==============================================================
# Application/network methods (mainly used for connected games).
# ==============================================================
def is_observer_power(self):
""" (Network Method) Return True if this power is an observer power. """
return self.role == strings.OBSERVER_TYPE
def is_omniscient_power(self):
""" (Network Method) Return True if this power is an omniscient power. """
return self.role == strings.OMNISCIENT_TYPE
def is_player_power(self):
""" (Network Method) Return True if this power is a player power. """
return self.role == self.name
def is_server_power(self):
""" (Network Method) Return True if this power is a server power. """
return self.role == strings.SERVER_TYPE
def is_controlled(self):
""" (Network Method) Return True if this power is controlled. """
return self.controller.last_value() != strings.DUMMY
def does_not_wait(self):
""" (Network Method) Return True if this power does not wait
(ie. if we could already process orders of this power).
"""
return self.order_is_set and not self.wait
def update_controller(self, username, timestamp):
""" (Network Method) Update controller with given username and timestamp. """
self.controller.put(timestamp, username)
def set_controlled(self, username):
""" (Network Method) Control power with given username. Username may be None (meaning no controller). """
if username is None or username == strings.DUMMY:
if self.controller.last_value() != strings.DUMMY:
self.controller.put(common.timestamp_microseconds(),
strings.DUMMY)
self.tokens.clear()
self.wait = True
self.vote = strings.NEUTRAL
elif self.controller.last_value() == strings.DUMMY:
self.controller.put(common.timestamp_microseconds(), username)
self.wait = not self.game.real_time
elif self.controller.last_value() != username:
raise DiplomacyException(
'Power already controlled by someone else. Kick previous controller before.'
)
def get_controller(self):
""" (Network Method) Return current power controller name ('dummy' if power is not controlled). """
return self.controller.last_value()
def get_controller_timestamp(self):
""" (Network Method) Return timestamp when current controller took control of this power. """
return self.controller.last_key()
def is_controlled_by(self, username):
""" (Network Method) Return True if this power is controlled by given username. """
if username == constants.PRIVATE_BOT_USERNAME:
# Bot is connected if power is dummy and has some associated tokens.
return self.is_dummy() and bool(self.tokens)
return self.controller.last_value() == username
# Server-only methods.
def has_token(self, token):
""" (Server Method) Return True if this power has given token. """
assert self.is_server_power()
return token in self.tokens
def add_token(self, token):
""" (Server Method) Add given token to this power. """
assert self.is_server_power()
self.tokens.add(token)
def remove_tokens(self, tokens):
""" (Server Method) Remove sequence of tokens from this power. """
assert self.is_server_power()
self.tokens.difference_update(tokens)
class Users(Jsonable):
""" Users class.
Properties:
- **users**: dictionary mapping usernames to User object.s
- **administrators**: set of administrator usernames.
- **token_timestamp**: dictionary mapping each token to its creation/last confirmation timestamp.
- **token_to_username**: dictionary mapping each token to its username.
- **username_to_tokens**: dictionary mapping each username to a set of its tokens.
- **token_to_connection_handler**: (memory only) dictionary mapping each token to a connection handler
- **connection_handler_to_tokens**: (memory only) dictionary mapping a connection handler to a set of its tokens
"""
__slots__ = [
'users', 'administrators', 'token_timestamp', 'token_to_username',
'username_to_tokens', 'token_to_connection_handler',
'connection_handler_to_tokens'
]
model = {
strings.USERS:
parsing.DefaultValueType(
parsing.DictType(str, parsing.JsonableClassType(User)), {}),
# {username => User}
strings.ADMINISTRATORS:
parsing.DefaultValueType(
parsing.SequenceType(str, sequence_builder=set), ()),
# {usernames}
strings.TOKEN_TIMESTAMP:
parsing.DefaultValueType(parsing.DictType(str, int), {}),
strings.TOKEN_TO_USERNAME:
parsing.DefaultValueType(parsing.DictType(str, str), {}),
strings.USERNAME_TO_TOKENS:
parsing.DefaultValueType(
parsing.DictType(str, parsing.SequenceType(str, set)), {}),
}
def __init__(self, **kwargs):
self.users = {}
self.administrators = set()
self.token_timestamp = {}
self.token_to_username = {}
self.username_to_tokens = {}
self.token_to_connection_handler = {}
self.connection_handler_to_tokens = {}
super(Users, self).__init__(**kwargs)
def has_username(self, username):
""" Return True if users have given username. """
return username in self.users
def has_user(self, username, password):
""" Return True if users have given username with given password. """
return username in self.users and self.users[
username].is_valid_password(password)
def has_admin(self, username):
""" Return True if given username is an administrator. """
return username in self.administrators
def has_token(self, token):
""" Return True if users have given token. """
return token in self.token_to_username
def token_is_alive(self, token):
""" Return True if given token is known and still alive.
A token is alive if elapsed time since last token usage does not exceed token lifetime
(TOKEN_LIFETIME_SECONDS).
"""
if self.has_token(token):
current_time = common.timestamp_microseconds()
elapsed_time_seconds = (current_time -
self.token_timestamp[token]) / 1000000
return elapsed_time_seconds <= TOKEN_LIFETIME_SECONDS
return False
def relaunch_token(self, token):
""" Update timestamp of given token with current timestamp. """
if self.has_token(token):
self.token_timestamp[token] = common.timestamp_microseconds()
def token_is_admin(self, token):
""" Return True if given token is associated to an administrator. """
return self.has_token(token) and self.has_admin(self.get_name(token))
def count_connections(self):
""" Return number of registered connection handlers. """
return len(self.connection_handler_to_tokens)
def get_tokens(self, username):
""" Return a sequence of tokens associated to given username. """
return self.username_to_tokens[username].copy()
def get_name(self, token):
""" Return username of given token. """
return self.token_to_username[token]
def get_user(self, username):
""" Returns user linked to username """
return self.users.get(username, None)
def get_connection_handler(self, token):
""" Return connection handler associated to given token, or None if no handler currently associated. """
return self.token_to_connection_handler.get(token, None)
def add_admin(self, username):
""" Set given username as administrator. Related user must exists in this Users object. """
assert username in self.users
self.administrators.add(username)
def remove_admin(self, username):
""" Remove given username from administrators. """
if username in self.administrators:
self.administrators.remove(username)
def create_token(self):
""" Return a new token guaranteed to not exist in this Users object. """
token = generate_token()
while self.has_token(token):
token = generate_token()
return token
def add_user(self, username, password_hash):
""" Add a new user with given username and hashed password.
See diplomacy.utils.common.hash_password() for hashing purposes.
"""
user = User(username=username, password_hash=password_hash)
self.users[username] = user
return user
def replace_user(self, username, new_user):
""" Replaces user object with a new user """
self.users[username] = new_user
def remove_user(self, username):
""" Remove user related to given username. """
user = self.users.pop(username)
self.remove_admin(username)
for token in self.username_to_tokens.pop(user.username):
self.token_timestamp.pop(token)
self.token_to_username.pop(token)
connection_handler = self.token_to_connection_handler.pop(
token, None)
if connection_handler:
self.connection_handler_to_tokens[connection_handler].remove(
token)
if not self.connection_handler_to_tokens[connection_handler]:
self.connection_handler_to_tokens.pop(connection_handler)
def remove_connection(self, connection_handler, remove_tokens=True):
""" Remove given connection handler.
Return tokens associated to this connection handler,
or None if connection handler is unknown.
:param connection_handler: connection handler to remove.
:param remove_tokens: if True, tokens related to connection handler are deleted.
:return: either None or a set of tokens.
"""
if connection_handler in self.connection_handler_to_tokens:
tokens = self.connection_handler_to_tokens.pop(connection_handler)
for token in tokens:
self.token_to_connection_handler.pop(token)
if remove_tokens:
self.token_timestamp.pop(token)
user = self.users[self.token_to_username.pop(token)]
self.username_to_tokens[user.username].remove(token)
if not self.username_to_tokens[user.username]:
self.username_to_tokens.pop(user.username)
return tokens
return None
def connect_user(self, username, connection_handler):
""" Connect given username to given connection handler with a new generated token,
and return token generated.
:param username: username to connect
:param connection_handler: connection handler to link to user
:return: a new token generated for connexion
"""
token = self.create_token()
user = self.users[username]
if connection_handler not in self.connection_handler_to_tokens:
self.connection_handler_to_tokens[connection_handler] = set()
if user.username not in self.username_to_tokens:
self.username_to_tokens[user.username] = set()
self.token_to_username[token] = user.username
self.token_to_connection_handler[token] = connection_handler
self.username_to_tokens[user.username].add(token)
self.connection_handler_to_tokens[connection_handler].add(token)
self.token_timestamp[token] = common.timestamp_microseconds()
return token
def attach_connection_handler(self, token, connection_handler):
""" Associate given token with given connection handler if token is known.
If there is a previous connection handler associated to given token, it should be
the same as given connection handler, otherwise an error is raised
(meaning previous connection handler was not correctly disconnected from given token.
It should be a programming error).
:param token: token
:param connection_handler: connection handler
"""
if self.has_token(token):
previous_connection = self.get_connection_handler(token)
if previous_connection:
assert previous_connection == connection_handler, \
"A new connection handler cannot be attached to a token always connected to another handler."
else:
LOGGER.warning(
'Attaching a new connection handler to a token.')
if connection_handler not in self.connection_handler_to_tokens:
self.connection_handler_to_tokens[
connection_handler] = set()
self.token_to_connection_handler[token] = connection_handler
self.connection_handler_to_tokens[connection_handler].add(
token)
self.token_timestamp[token] = common.timestamp_microseconds()
def disconnect_token(self, token):
""" Remove given token. """
self.token_timestamp.pop(token)
user = self.users[self.token_to_username.pop(token)]
self.username_to_tokens[user.username].remove(token)
if not self.username_to_tokens[user.username]:
self.username_to_tokens.pop(user.username)
connection_handler = self.token_to_connection_handler.pop(token, None)
if connection_handler:
self.connection_handler_to_tokens[connection_handler].remove(token)
if not self.connection_handler_to_tokens[connection_handler]:
self.connection_handler_to_tokens.pop(connection_handler)
class DataGamesToPowerNames(UniqueData):
""" Unique data containing a dictionary mapping a game ID to a list of power names. """
__slots__ = []
params = {strings.DATA: parsing.DictType(str, parsing.SequenceType(str))}
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
# details.
#
# You should have received a copy of the GNU Affero General Public License along
# with this program. If not, see <https://www.gnu.org/licenses/>.
# ==============================================================================
""" Utility class to save all data related to one game phase (phase name, state, messages and orders). """
from diplomacy.engine.message import Message
from diplomacy.utils import common, strings, parsing
from diplomacy.utils.jsonable import Jsonable
from diplomacy.utils.sorted_dict import SortedDict
MESSAGES_TYPE = parsing.IndexedSequenceType(
parsing.DictType(int, parsing.JsonableClassType(Message),
SortedDict.builder(int, Message)), 'time_sent')
class GamePhaseData(Jsonable):
""" Small class to represent data for a game phase:
phase name, state, orders, orders results and messages for this phase.
"""
__slots__ = ['name', 'state', 'orders', 'results', 'messages']
model = {
strings.NAME:
str,
strings.STATE:
dict,
strings.ORDERS:
parsing.DictType(str,
