def add_player_to_lineup(self, player: Player):
"""
Force add specified player to lineup.
Return true if player successfully added to lineup.
"""
if player.max_exposure == 0:
raise LineupOptimizerException(
'Can\'t add this player to line up! Player has max exposure set to 0.'
)
if player in self._lineup:
raise LineupOptimizerException(
'This player already in your line up!')
if self.remaining_budget and player.salary > self.remaining_budget:
raise LineupOptimizerException(
'Can\'t add this player to line up! Your team is over budget!')
if self.remaining_players < 1:
raise LineupOptimizerException(
'Can\'t add this player to line up! You already select all %s players!'
% len(self.locked_players))
if self.max_from_one_team:
from_same_team = len(
[p for p in self.locked_players if p.team == player.team])
if from_same_team + 1 > self.max_from_one_team:
raise LineupOptimizerException(
'You can\'t set more than %s players from one team.' %
self.max_from_one_team)
try:
link_players_with_positions(self.locked_players + [player],
self._settings.positions)
except LineupOptimizerException:
raise LineupOptimizerException('You\'re already select all %s\'s' %
'/'.join(player.positions))
self._lineup.append(player)
def lock_player(self, player: DirtyPlayer, position: Optional[str] = None):
player = self._clean_player(player)
if player.max_exposure == 0:
raise LineupOptimizerException(
'Can\'t add this player to line up! Player has max exposure set to 0.'
)
if player in self._locked_players:
raise LineupOptimizerException(
'This player already in your line up!')
if self.remaining_budget and player.salary > self.remaining_budget:
raise LineupOptimizerException(
'Can\'t add this player to line up! Your team is over budget!')
if self.remaining_players < 1:
raise LineupOptimizerException(
'Can\'t add this player to line up! You already select all %s players!'
% len(self.locked_players))
max_from_one_team = self._settings.max_from_one_team
if max_from_one_team:
from_same_team = len(
[p for p in self.locked_players if p.team == player.team])
if from_same_team + 1 > max_from_one_team:
raise LineupOptimizerException(
'You can\'t set more than %s players from one team.' %
max_from_one_team)
position_for_player = None
if position:
if position not in self.available_positions:
raise LineupOptimizerException(
'Position %s doesn\'t exist. Available positions are %s' %
(position, ','.join(self.available_positions)))
for remaining_position in self._remaining_positions:
if position:
if position == remaining_position.name:
position_for_player = remaining_position
break
else:
raise LineupOptimizerException('Position %s is filled.' %
position)
if not list_intersection(player.positions,
position_for_player.positions):
raise LineupOptimizerException(
'Player can\'t be set to position %s' % position)
try:
link_players_with_positions({player, *self._locked_players},
self._settings.positions)
except LineupOptimizerException:
raise LineupOptimizerException('You\'re already select all %s\'s' %
'/'.join(player.positions))
if position_for_player:
self._remaining_positions.remove(position_for_player)
self._locked_players[player] = position_for_player
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)
