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 _build_lineup(
self,
players: List[Player],
context: OptimizationContext,
unswappable_players: Optional[List[LineupPlayer]] = None,
) -> Lineup:
lineup = []
positions = self._settings.positions[:]
if not positions:
for player in sorted(players, key=lambda p: p.positions[0]):
lineup.append(
LineupPlayer(
player,
player.positions[0],
used_fppg=context.players_used_fppg.get(player)))
return Lineup(lineup, self._settings.lineup_printer)
if unswappable_players:
players = [
player for player in players
if player not in unswappable_players
]
positions = get_remaining_positions(positions, unswappable_players)
lineup.extend(unswappable_players)
players_with_positions = link_players_with_positions(
players, positions)
for player, position in players_with_positions.items():
lineup.append(
LineupPlayer(player,
position.name,
used_fppg=context.players_used_fppg.get(player)))
positions_order = [pos.name for pos in self._settings.positions]
lineup.sort(key=lambda p: positions_order.index(p.lineup_position))
return Lineup(lineup, self._settings.lineup_printer)
def _build_lineup(self, players, unswappable_players=None):
# type: (List[Player], Optional[List[LineupPlayer]]) -> Lineup
lineup = []
positions = self._settings.positions[:]
if unswappable_players:
players = [
player for player in players
if player not in unswappable_players
]
positions = get_remaining_positions(positions, unswappable_players)
lineup.extend(unswappable_players)
players_with_positions = link_players_with_positions(
players, positions)
for player, position in players_with_positions.items():
lineup.append(LineupPlayer(player, position.name))
positions_order = [pos.name for pos in self._settings.positions]
lineup.sort(key=lambda p: positions_order.index(p.lineup_position))
return Lineup(lineup, self._settings.lineup_printer)
