def set_min_salary_cap(self, min_salary: float):
if min_salary > self.budget:
raise LineupOptimizerException(
'Min salary greater than max budget')
self.add_new_rule(MinSalaryCapRule)
self.min_salary_cap = min_salary
def print_statistic(self) -> None:
if self.last_context is None:
raise LineupOptimizerException(
'You should generate lineups before printing statistic')
Statistic(self).print_report()
def export(self, filename: str) -> None:
if self.last_context is None:
raise LineupOptimizerException(
'You should generate lineups before printing statistic')
self.settings.csv_exporter(self.last_context.lineups).export(filename)
def optimize(
self,
n: int,
max_exposure: Optional[float] = None,
randomness: bool = False,
with_injured: bool = False,
exposure_strategy: Type[BaseExposureStrategy] = TotalExposureStrategy,
) -> Generator[Lineup, None, None]:
players = [
player for player in self.players
if player.max_exposure is None or player.max_exposure > 0
]
context = OptimizationContext(
total_lineups=n,
players=players,
max_exposure=max_exposure,
randomness=randomness,
with_injured=with_injured,
exposure_strategy=exposure_strategy,
)
n = int(n)
rules = self._rules.copy()
rules.update(self.settings.extra_rules)
if randomness:
rules.add(RandomObjective)
else:
rules.add(NormalObjective)
if with_injured:
rules.remove(RemoveInjuredRule)
base_solver = self._solver_class()
base_solver.setup_solver()
players_dict = OrderedDict([(player,
base_solver.add_variable('Player_%d' % i))
for i, player in enumerate(players)])
variables_dict = {v: k for k, v in players_dict.items()}
constraints = [
constraint(self, players_dict, context) for constraint in rules
]
for constraint in constraints:
constraint.apply(base_solver)
previous_lineup = None
for _ in range(n):
solver = base_solver.copy() # type: Solver
for constraint in constraints:
constraint.apply_for_iteration(solver, previous_lineup)
try:
solved_variables = solver.solve()
lineup_players = []
variables_names = []
for solved_variable in solved_variables:
player = variables_dict.get(solved_variable)
if player:
lineup_players.append(player)
variables_names.append(solved_variable.name)
lineup = self._build_lineup(lineup_players, context)
previous_lineup = lineup
context.add_lineup(lineup)
yield lineup
if self.total_players and len(
self.locked_players) == self.total_players:
return
for constraint in constraints:
constraint.post_optimize(variables_names)
except SolverException:
raise LineupOptimizerException('Can\'t generate lineups')
self.last_context = context
def remove_rule(self, rule: Type[OptimizerRule], silent: bool = True):
try:
self._rules.remove(rule)
except KeyError:
if not silent:
raise LineupOptimizerException('Rule isn\'t added!')
def export(self, filename: str, with_excluded: bool = True) -> None:
if self.last_context is None:
raise LineupOptimizerException('You should generate lineups before printing statistic')
self.settings.csv_exporter(self.last_context.get_lineups(with_excluded)).export(filename)
def restrict_positions_for_opposing_team(self, first_team_positions, second_team_positions):
# type: (List[str], List[str]) -> None
if not self.games:
raise LineupOptimizerException('Game Info isn\'t specified for players')
self._opposing_teams_position_restriction = (first_team_positions, second_team_positions)
self.add_new_rule(RestrictPositionsForOpposingTeams)
def restore_player(self, player: DirtyPlayer):
try:
self.removed_players.remove(self._clean_player(player))
except KeyError:
raise LineupOptimizerException('Player not removed!')
