def apply_for_iteration(self, solver, players_dict, result):
current_lineup = self.lineups[self.current_iteration]
unswappable_players = current_lineup.get_unswappable_players()
remaining_positions = get_remaining_positions(
self.optimizer.settings.positions, unswappable_players)
# lock selected players
for player in unswappable_players:
solver.add_constraint([players_dict[player]], None, SolverSign.EQ,
1)
# set remaining positions
positions_combinations = set([
tuple(sorted(player.positions)) for player in players_dict.keys()
if len(player.positions) > 1
])
positions = get_positions_for_optimizer(remaining_positions,
positions_combinations)
players_for_optimization = set()
for position, places in positions.items():
players_with_position = [
variable for player, variable in players_dict.items()
if list_intersection(position, player.positions)
and player not in unswappable_players
]
players_for_optimization.update(players_with_position)
solver.add_constraint(players_with_position, None, SolverSign.GTE,
places)
# Set total players for optimization
solver.add_constraint(players_for_optimization, None, SolverSign.EQ,
len(remaining_positions))
# Exclude players with active games
for player, variable in players_dict.items():
if player not in unswappable_players and player.is_game_started:
solver.add_constraint([players_dict[player]], None,
SolverSign.EQ, 0)
self.current_iteration += 1
def apply_for_iteration(self, solver, players_dict, result):
current_lineup = self.lineups[self.current_iteration]
unswappable_players = current_lineup.get_unswappable_players()
positions = self.optimizer.settings.positions[:]
# lock selected players
for player in unswappable_players:
for position in positions:
if position.name == player.lineup_position:
positions.remove(position)
break
solver.add_constraint([players_dict[player]], [1], SolverSign.EQ,
1)
# set remaining positions
positions = get_positions_for_optimizer(positions)
for position, places in positions.items():
players_with_position = [
variable for player, variable in players_dict.items()
if list_intersection(position, player.positions)
and player not in unswappable_players
]
coefficients = [1] * len(players_with_position)
solver.add_constraint(players_with_position, coefficients,
SolverSign.GTE, places)
# Exclude players with active games
for player, variable in players_dict.items():
if player not in unswappable_players and player.is_game_started:
solver.add_constraint([players_dict[player]], [1],
SolverSign.EQ, 0)
self.current_iteration += 1
def apply(self, solver, players_dict):
optimizer = self.optimizer
extra_positions = optimizer.players_with_same_position
positions_combinations = set([
tuple(sorted(player.positions)) for player in players_dict.keys()
if len(player.positions) > 1
])
for rank, rank_positions in groupby(optimizer.settings.positions,
lambda pos: pos.for_rank):
positions = get_positions_for_optimizer(list(rank_positions),
positions_combinations)
unique_positions = optimizer.available_positions
players_by_positions = {
position: {
variable
for player, variable in players_dict.items()
if player.rank == rank and position in player.positions
}
for position in unique_positions
}
for position, places in positions.items():
extra = 0
if len(position) == 1:
extra = extra_positions.get(position[0], 0)
players_with_position = set()
for pos in position:
players_with_position.update(players_by_positions[pos])
solver.add_constraint(players_with_position, None,
SolverSign.GTE, places + extra)
def apply(self, solver):
optimizer = self.optimizer
if not optimizer.available_positions:
return
extra_positions = optimizer.players_with_same_position
positions_combinations = set([
tuple(sorted(player.positions))
for player in self.players_dict.keys() if len(player.positions) > 1
])
positions = get_positions_for_optimizer(optimizer.settings.positions,
positions_combinations)
unique_positions = optimizer.available_positions
players_by_positions = {
position: {
variable
for player, variable in self.players_dict.items()
if position in player.positions
}
for position in unique_positions
}
for position, places in positions.items():
extra = 0
if len(position) == 1:
extra = extra_positions.get(position[0], 0)
players_with_position = set()
for pos in position:
players_with_position.update(players_by_positions[pos])
solver.add_constraint(players_with_position,
None,
SolverSign.GTE,
places + extra,
name='positions_%s' % '_'.join(position))
def test_optimizer_positions_processing(self):
optimizer = LineupOptimizer(self.TestSettings)
positions = get_positions_for_optimizer(optimizer.settings.positions)
self.assertEqual(len(positions), 5)
self.assertEqual(positions[('1', )], 1)
self.assertEqual(positions[('2', )], 1)
self.assertEqual(positions[('3', )], 1)
self.assertEqual(positions[('2', '3')], 4)
self.assertEqual(positions[('1', '2', '3')], 7)
def __init__(self, optimizer, players_dict, context):
super().__init__(optimizer, players_dict, context)
self.min_exposure_players = {
player: round(player.min_exposure * context.total_lineups)
for player in context.players if player.min_exposure
}
self.positions = {} # type: Dict[Tuple[str, ...], int]
if self.min_exposure_players:
self.positions = get_positions_for_optimizer(optimizer.settings.positions, None)
def __init__(self, optimizer, all_players, params):
super().__init__(optimizer, all_players, params)
self.total_lineups = params.get('n')
self.remaining_lineups = self.total_lineups
self.min_exposure_players = {
player: round(player.min_exposure * self.total_lineups)
for player in all_players if player.min_exposure
}
self.positions = {}
if self.min_exposure_players:
self.positions = get_positions_for_optimizer(optimizer.settings.positions, None)
def test_optimizer_positions_processing_with_multipositions(self):
optimizer = LineupOptimizer(self.TestSettings)
positions = get_positions_for_optimizer(optimizer.settings.positions,
{('1', '2'), ('2', '3'),
('1', '3')})
self.assertEqual(len(positions), 7)
self.assertEqual(positions[('1', )], 1)
self.assertEqual(positions[('2', )], 1)
self.assertEqual(positions[('3', )], 1)
self.assertEqual(positions[('2', '3')], 4)
self.assertEqual(positions[('1', '2')], 2)
self.assertEqual(positions[('1', '3')], 2)
self.assertEqual(positions[('1', '2', '3')], 7)
def apply(self, solver, players_dict):
extra_positions = self.optimizer.players_with_same_position
positions = get_positions_for_optimizer(
self.optimizer._settings.positions)
for position, places in positions.items():
extra = 0
if len(position) == 1:
extra = extra_positions.get(position[0], 0)
players_with_position = [
variable for player, variable in players_dict.items()
if list_intersection(position, player.positions)
]
coefficients = [1] * len(players_with_position)
solver.add_constraint(players_with_position, coefficients,
SolverSign.GTE, places + extra)
def apply(self, solver, players_dict):
extra_positions = self.optimizer.players_with_same_position
positions = get_positions_for_optimizer(
self.optimizer.settings.positions)
unique_positions = self.optimizer.available_positions
players_by_positions = {
position: {
variable
for player, variable in players_dict.items()
if position in player.positions
}
for position in unique_positions
}
for position, places in positions.items():
extra = 0
if len(position) == 1:
extra = extra_positions.get(position[0], 0)
players_with_position = set()
for pos in position:
players_with_position.update(players_by_positions[pos])
solver.add_constraint(players_with_position, None, SolverSign.GTE,
places + extra)
