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)