def test_uniques_nba():
roster = run(
rule_set=rules.DK_NBA_RULE_SET,
player_pool=mock_nba_pool,
)
second_roster = run(
rule_set=rules.DK_NBA_RULE_SET,
player_pool=mock_nba_pool,
optimizer_settings=OptimizerSettings(existing_rosters=[roster], ),
)
third_roster = run(
rule_set=rules.DK_NBA_RULE_SET,
player_pool=mock_nba_pool,
optimizer_settings=OptimizerSettings(
existing_rosters=[roster],
uniques=2,
),
)
players = roster.sorted_players()
second_players = second_roster.sorted_players()
third_players = third_roster.sorted_players()
crossover_a = list(set(players).intersection(second_players))
crossover_b = list(set(players).intersection(third_players))
ntools.assert_equal(len(crossover_a),
rules.DK_NBA_RULE_SET.roster_size - 1)
ntools.assert_equal(len(crossover_b),
rules.DK_NBA_RULE_SET.roster_size - 2)
def test_no_opposing_def_dk_nfl():
players = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
projection_file_location=projection_file,
game=rules.DRAFT_KINGS,
)
roster = run(
rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
optimizer_settings=OptimizerSettings(no_offense_against_defense=True),
constraints=LineupConstraints(locked=['Bengals']),
verbose=True)
for p in roster.players:
if p.pos in rules.DK_NFL_RULE_SET.offensive_positions:
ntools.assert_not_equal(p.team, 'CIN')
# force impossible lineup
roster = run(
rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
optimizer_settings=OptimizerSettings(no_offense_against_defense=True),
constraints=LineupConstraints(locked=['Bengals', 'Ryan Fitzpatrick']),
verbose=True)
ntools.assert_equal(roster, None)
def test_no_opposing_def_fd_nfl():
players = salary_download.generate_players_from_csvs(
salary_file_location=fd_nfl_salary_file,
game=rules.FAN_DUEL,
)
roster = run(
rule_set=rules.FD_NFL_RULE_SET,
player_pool=players,
optimizer_settings=OptimizerSettings(no_offense_against_defense=True),
constraints=LineupConstraints(locked=['Jacksonville Jaguars']),
verbose=True)
ntools.assert_not_equal(roster, None)
for p in roster.players:
if p.pos in rules.DK_NFL_RULE_SET.offensive_positions:
ntools.assert_not_equal(p.team, 'IND')
# force impossible lineup
roster = run(
rule_set=rules.FD_NFL_RULE_SET,
player_pool=players,
optimizer_settings=OptimizerSettings(no_offense_against_defense=True),
constraints=LineupConstraints(
locked=['Eric Ebron', 'Jacksonville Jaguars']),
verbose=True)
ntools.assert_equal(roster, None)
def test_force_combo():
# no combo
players = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
projection_file_location=projection_file,
game=rules.DRAFT_KINGS,
)
roster = run(rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
player_settings=PlayerPoolSettings(locked=['Sam Bradford'], ),
optimizer_settings=OptimizerSettings(
stack_team='NE',
stack_count=5,
))
qb = roster.sorted_players()[0]
team_count = len([x for x in roster.sorted_players() if x.team == qb.team])
ntools.assert_equals(team_count, 1)
# QB/WR combo
players = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
projection_file_location=projection_file,
game=rules.DRAFT_KINGS,
)
roster = run(rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
optimizer_settings=OptimizerSettings(force_combo=True, ))
qb = roster.sorted_players()[0]
ntools.assert_equal(qb.pos, 'QB')
def test_te_combo():
# use lock and ban to make a non-globally optimal QB/TE combo optimal
players = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
projection_file_location=projection_file,
game=rules.DRAFT_KINGS,
)
roster = run(
rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
optimizer_settings=OptimizerSettings(
force_combo=True,
combo_allow_te=True,
),
constraints=LineupConstraints(
banned=['Kellen Davis'],
locked=['Philip Rivers'],
),
verbose=True,
)
qb = roster.sorted_players()[0]
ntools.assert_equal(qb.pos, 'QB')
team_count = len([
x for x in roster.sorted_players()
if x.team == qb.team and x.pos == 'TE'
])
ntools.assert_equals(team_count, 1)
# make sure WR/QB still works
players = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
projection_file_location=projection_file,
game=rules.DRAFT_KINGS,
)
roster = run(
rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
optimizer_settings=OptimizerSettings(
force_combo=True,
combo_allow_te=True,
),
constraints=LineupConstraints(locked=['Andrew Luck'], ),
verbose=True,
)
qb = roster.sorted_players()[0]
ntools.assert_equal(qb.pos, 'QB')
team_count = len([
x for x in roster.sorted_players()
if x.team == qb.team and x.pos == 'WR'
])
ntools.assert_equals(team_count, 1)
def test_soccer_dk_no_opp_d():
player_pool = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
game=rules.DRAFT_KINGS,
)
roster = run(
rule_set=rules.DK_SOCCER_RULE_SET,
player_pool=player_pool,
constraints=LineupConstraints(
locked=['Maxi Gomez'],
),
optimizer_settings=OptimizerSettings(
no_offense_against_defense=False,
),
verbose=True,
)
cel_off_players = [
p for p in roster.players if p.team == 'CEL'
and p.pos in ['M', 'F']
]
lgn_d_players = [
p for p in roster.players if p.team == 'LGN'
and p.pos in ['D', 'GK']
]
ntools.assert_equal(len(cel_off_players), 2)
ntools.assert_equal(len(lgn_d_players), 2)
roster = run(
rule_set=rules.DK_SOCCER_RULE_SET,
player_pool=player_pool,
constraints=LineupConstraints(
locked=['Maxi Gomez'],
),
optimizer_settings=OptimizerSettings(
no_offense_against_defense=True,
),
verbose=True,
)
cel_off_players = [
p for p in roster.players if p.team == 'CEL'
and p.pos in ['M', 'F']
]
lgn_d_players = [
p for p in roster.players if p.team == 'LGN'
and p.pos in ['D', 'GK']
]
ntools.assert_equal(len(cel_off_players), 2)
ntools.assert_equal(len(lgn_d_players), 0)
def run_multi(
iterations: int,
rule_set: RuleSet,
player_pool: list,
constraints: LineupConstraints = LineupConstraints(),
player_settings: PlayerPoolSettings = PlayerPoolSettings(),
optimizer_settings: OptimizerSettings = OptimizerSettings(),
verbose=False,
exposure_bounds: List[dict] = list(),
exposure_random_seed=None,
) -> [List[Roster], list]:
# set the random seed globally for random lineup exposure
random.seed(exposure_random_seed)
rosters = []
for _ in range(0, iterations):
exposure_dict = get_exposure_args(
existing_rosters=optimizer_settings.existing_rosters,
exposure_bounds=exposure_bounds,
n=iterations,
use_random=bool(exposure_random_seed),
random_seed=exposure_random_seed,
)
roster = run(
rule_set=rule_set,
player_pool=player_pool,
optimizer_settings=optimizer_settings,
player_settings=player_settings,
exposure_dict=exposure_dict,
constraints=constraints,
verbose=verbose,
)
if roster:
optimizer_settings.existing_rosters += [roster]
if roster:
rosters.append(roster)
else:
break
# clear ban/lock to reset exposure between iterations
reset_player_ban_lock(player_pool)
exposure_diffs = {}
if rosters and verbose:
print(get_exposure_table(rosters, exposure_bounds))
print()
print(get_exposure_matrix(rosters))
print()
exposure_diffs = check_exposure(rosters, exposure_bounds)
for n, d in exposure_diffs.items():
if d < 0:
print('{} is UNDER exposure by {} lineups'.format(n, d))
else:
print('{} is OVER exposure by {} lineups'.format(n, d))
return rosters, exposure_diffs
def test_if_one_then_two():
mock_nba_pool = construct_pool()
# Base case
roster = run(
rule_set=rules.DK_NBA_RULE_SET,
player_pool=mock_nba_pool,
verbose=True,
)
names = {p.name for p in roster.players}
ntools.assert_equal(
True, 'A1' in names and 'A4' not in names and 'A9' not in names)
settings = OptimizerSettings(custom_rules=[
# Always play A1 with A9 and A4
CustomRule(group_a=lambda p: p.name == 'A1',
group_b=lambda p: p.name == 'A9' or p.name == 'A4')
])
# TODO - add test where A1 is not in optimized lineup
roster = run(
rule_set=rules.DK_NBA_RULE_SET,
player_pool=mock_nba_pool,
verbose=True,
optimizer_settings=settings,
)
names = {p.name for p in roster.players}
# Without this rule, A4 and A9 would never appear in the optimized
# lineup. Both have a 0 point projection.
ntools.assert_equal(True, 'A1' in names and 'A9' in names
and 'A4' in names)
def test_custom_stack():
players = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
projection_file_location=projection_file,
game=rules.DRAFT_KINGS,
)
roster = run(
rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
optimizer_settings=OptimizerSettings(stacks=[
Stack(
team='NE',
count=5,
stack_lock_pos=['QB'],
stack_eligible_pos=['WR'],
)
]),
verbose=True,
)
ne_players_count = len(
[p for p in roster.sorted_players() if p.team == 'NE'])
ntools.assert_equals(5, ne_players_count)
ne_def = len([
p for p in roster.sorted_players() if p.team == 'NE' and p.pos == 'DST'
])
ntools.assert_equals(ne_def, 0)
wides = len([
p for p in roster.sorted_players() if p.team == 'NE' and p.pos == 'WR'
])
ntools.assert_equals(wides, 4)
def test_never_two():
mock_nba_pool = construct_pool()
# Base case
roster = run(
rule_set=rules.DK_NBA_RULE_SET,
player_pool=mock_nba_pool,
verbose=True,
)
names = {p.name for p in roster.players}
ntools.assert_equal(True, 'A101' in names and 'A100' in names)
# Never play two players together
settings = OptimizerSettings(custom_rules=[
CustomRule(group_a=lambda p: p,
group_b=lambda p: p.name == 'A100' or p.name == 'A101',
comparison=lambda sum, a, b: sum(b) <= 1)
])
roster = run(
rule_set=rules.DK_NBA_RULE_SET,
player_pool=mock_nba_pool,
verbose=True,
optimizer_settings=settings,
)
names = {p.name for p in roster.players}
# Without this rule, A4 and A9 would never appear in the optimized
# lineup. Both have a 0 point projection.
ntools.assert_equal(True, 'A101' not in names and 'A100' in names)
def run_multi(
iterations: int,
rule_set: RuleSet,
player_pool: list,
player_settings=PlayerPoolSettings(),
optimizer_settings=OptimizerSettings(),
verbose=False,
exposure_bounds=None,
exposure_random_seed=None,
) -> [List[Roster], list]:
# set the random seed globally for random lineup exposure
if exposure_random_seed:
random.seed(exposure_random_seed)
rosters = []
for _ in range(0, iterations):
if exposure_bounds:
exposure_dct = get_exposure_args(
existing_rosters=optimizer_settings.existing_rosters,
exposure_bounds=exposure_bounds,
n=iterations,
use_random=bool(exposure_random_seed),
random_seed=exposure_random_seed,
)
player_settings.banned = exposure_dct['banned']
player_settings.locked = exposure_dct['locked']
roster = run(
rule_set=rule_set,
player_pool=player_pool,
optimizer_settings=optimizer_settings,
player_settings=player_settings,
verbose=verbose,
)
if roster:
optimizer_settings.existing_rosters += [roster]
if roster:
rosters.append(roster)
else:
break
exposure_diffs = {}
if rosters and verbose:
print(get_exposure_table(rosters, exposure_bounds))
print()
print(get_exposure_matrix(rosters))
print()
exposure_diffs = check_exposure(rosters, exposure_bounds)
for n, d in exposure_diffs.items():
if d < 0:
print('{} is UNDER exposure by {} lineups'.format(n, d))
else:
print('{} is OVER exposure by {} lineups'.format(n, d))
return rosters, exposure_diffs
def test_custom_rules():
# Minimum stack size
custom_rules = []
player_pool = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
game=rules.DRAFT_KINGS,
ruleset=rules.DK_MLB_RULE_SET,
)
for p in player_pool:
if p.team == 'ATL' and p.pos == '1B':
p.proj = 1_000
def comp(sum, a, b):
return sum(b) >= sum(a) + 2
# It appears to me closures do not work with ortools
# (ex. passing p.team == t)
custom_rules.append(
CustomRule(
# Given 1B in optimized lineup
group_a=lambda p:
p.pos == '1B' and p.team == 'ATL',
# Ensure the stack is four players
group_b=lambda p:
'1B' not in p.pos and p.team == 'ATL', # batters only
comparison=comp,
)
)
custom_rules.append(
CustomRule(
# Given 1B in optimized lineup
group_a=lambda p:
p.pos == '1B' and p.team == 'BOS',
# Ensure the stack is four players
group_b=lambda p:
'1B' not in p.pos and p.team == 'BOS', # batters only
comparison=comp,
)
)
settings = OptimizerSettings(
custom_rules=custom_rules
)
roster = run(
rule_set=rules.DK_MLB_RULE_SET,
player_pool=player_pool,
verbose=True,
optimizer_settings=settings,
)
team_for_first = [p for p in roster.players if p.pos == '1B'][0].team
total = len([p for p in roster.players
if p.team == team_for_first and 'P' not in p.pos])
assert total > 3, f"{total} below 4"
def test_force_combo():
# no combo
players = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
projection_file_location=projection_file,
game=rules.DRAFT_KINGS,
)
roster = run(
rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
optimizer_settings=OptimizerSettings(
stacks=[Stack(team='NE', count=5)]),
constraints=LineupConstraints(locked=['Sam Bradford'], ),
)
qb = roster.sorted_players()[0]
team_count = len([x for x in roster.sorted_players() if x.team == qb.team])
ntools.assert_equals(team_count, 1)
# QB/WR combo
players = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
projection_file_location=projection_file,
game=rules.DRAFT_KINGS,
)
roster = run(
rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
optimizer_settings=OptimizerSettings(force_combo=True, ),
constraints=LineupConstraints(banned=['Ryan Fitzpatrick']),
verbose=True,
)
qb = roster.sorted_players()[0]
ntools.assert_equal(qb.pos, 'QB')
wr_team_count = len([
x for x in roster.sorted_players()
if x.team == qb.team and x.pos == 'WR'
])
ntools.assert_equals(wr_team_count, 1)
te_team_count = len([
x for x in roster.sorted_players()
if x.team == qb.team and x.pos == 'TE'
])
ntools.assert_equals(te_team_count, 0)
def _compile_params(self):
if self.stacks:
optimizers = OptimizerSettings(
stacks=[
Stack(
team=good['team'],
count=good['count'],
stack_lock_pos=good['lock'],
stack_eligible_pos=good['eligible']
)
for good in self.stacks
],
)
else:
optimizers = OptimizerSettings()
exposures = self.exposures
groups = []
if self.targets:
for k in self.targets.keys():
groups.append(
[
self.targets[k]['players'],
(
self.targets[k]['lower'],
self.targets[k]['upper']
)
]
)
if self.banned or groups:
constraints = LineupConstraints(
banned=self.banned,
groups=groups
)
else:
constraints = LineupConstraints()
return constraints, exposures, optimizers
def test_nfl_dk_showdown_mock():
mock_dk_pool = _build_mock_player_pool()
roster = run(rule_set=rules.DK_NFL_SHOWDOWN_RULE_SET,
player_pool=mock_dk_pool,
optimizer_settings=OptimizerSettings(showdown_teams=('X',
'Y'), ),
verbose=True)
ntools.assert_not_equal(roster, None)
ntools.assert_equal(roster.projected(), 421)
def test_no_mutate_side_Effect():
players = salary_download.generate_players_from_csvs(
salary_file_location=fd_nfl_salary_file,
game=rules.FAN_DUEL,
)
run(rule_set=rules.FD_NFL_RULE_SET,
player_pool=players,
optimizer_settings=OptimizerSettings(no_offense_against_defense=True),
constraints=LineupConstraints(locked=['Tom Brady']),
verbose=True)
brady = next((p for p in players if p.name == 'Tom Brady'))
ntools.assert_equal(brady.lock, False)
def test_csgo_mock():
mock_dk_pool = _build_mock_player_pool()
roster = run(
# CSGO limits three per team
rule_set=rules.DK_CSGO_SHOWDOWN,
player_pool=mock_dk_pool,
optimizer_settings=OptimizerSettings(showdown_teams=('X', 'Y'), ),
verbose=True)
ntools.assert_not_equal(roster, None)
players = roster.players
ntools.assert_equal(len([x for x in players if x.team == 'Y']), 3)
def test_nfl_showdown_ban_general():
mock_dk_pool = _build_mock_player_pool()
roster = run(rule_set=rules.DK_NFL_SHOWDOWN_RULE_SET,
player_pool=mock_dk_pool,
optimizer_settings=OptimizerSettings(
showdown_teams=('X', 'Y'),
no_defense_against_captain=True,
),
constraints=LineupConstraints(banned=['A1'], ),
verbose=True)
ntools.assert_not_equal(roster, None)
ntools.assert_equal(roster.projected(), 334.0)
ntools.assert_true('A1' not in [x.name for x in roster.players])
def test_multi_roster_nba():
roster = run(
rule_set=rules.DK_NBA_RULE_SET,
player_pool=mock_nba_pool,
)
second_roster = run(
rule_set=rules.DK_NBA_RULE_SET,
player_pool=mock_nba_pool,
optimizer_settings=OptimizerSettings(existing_rosters=[roster], ),
)
ntools.assert_not_equal(roster, None)
ntools.assert_not_equal(second_roster, None)
ntools.assert_false(roster.exact_equal(second_roster))
def test_nfl_showdown_no_def_against_capt():
mock_dk_pool = _build_mock_player_pool()
roster = run(rule_set=rules.DK_NFL_SHOWDOWN_RULE_SET,
player_pool=mock_dk_pool,
optimizer_settings=OptimizerSettings(
showdown_teams=('X', 'Y'),
no_defense_against_captain=True,
),
verbose=True)
ntools.assert_not_equal(roster, None)
ntools.assert_equal(roster.projected(), 408.0)
for p in roster.players:
ntools.assert_not_equal(p.name, 'A112')
def test_nfl_showdown_lock_captain():
mock_dk_pool = _build_mock_player_pool()
roster = run(rule_set=rules.DK_NFL_SHOWDOWN_RULE_SET,
player_pool=mock_dk_pool,
optimizer_settings=OptimizerSettings(
showdown_teams=('X', 'Y'),
no_defense_against_captain=True,
),
constraints=LineupConstraints(position_locked=['A2 CPT X'], ),
verbose=True)
ntools.assert_not_equal(roster, None)
ntools.assert_equal(roster.projected(), 370.5)
cpt = [x for x in roster.players if x.pos == 'CPT'][0]
ntools.assert_equal('A2', cpt.name)
def test_nfl_showdown_ban_specific():
mock_dk_pool = _build_mock_player_pool()
roster = run(rule_set=rules.DK_NFL_SHOWDOWN_RULE_SET,
player_pool=mock_dk_pool,
optimizer_settings=OptimizerSettings(
showdown_teams=('X', 'Y'),
no_defense_against_captain=True,
),
constraints=LineupConstraints(position_banned=['A1 CPT X'], ),
verbose=True)
ntools.assert_not_equal(roster, None)
ntools.assert_equal(roster.projected(), 386.0)
flex = [x for x in roster.players if x.pos == 'FLEX' and x.name == 'A1'][0]
ntools.assert_equal('A1', flex.name)
def test_stack():
players = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
projection_file_location=projection_file,
game=rules.DRAFT_KINGS,
)
roster = run(rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
optimizer_settings=OptimizerSettings(
stack_team='NE',
stack_count=5,
))
ne_players_count = len(
[p for p in roster.sorted_players() if p.team == 'NE'])
ntools.assert_equals(5, ne_players_count)
def test_if_one_then_one():
mock_nba_pool = construct_pool()
# Base case
roster = run(
rule_set=rules.DK_NBA_RULE_SET,
player_pool=mock_nba_pool,
verbose=True,
)
names = {p.name for p in roster.players}
ntools.assert_equal(True, 'A1' in names and 'A4' not in names)
settings = OptimizerSettings(custom_rules=[
# Always play A1 with A9 and A4
CustomRule(group_a=lambda p: p.name == 'A1',
group_b=lambda p: p.name == 'A4',
comparison=lambda s_sum, a, b: s_sum(a) == s_sum(b))
])
roster = run(
rule_set=rules.DK_NBA_RULE_SET,
player_pool=mock_nba_pool,
verbose=True,
optimizer_settings=settings,
)
names = {p.name for p in roster.players}
# Without this rule, A1 and A4 are not in the same lineup.
ntools.assert_equal(True, 'A1' in names and 'A4' in names)
# Confirm now that the rule prevents one without the other
mock_nba_pool = construct_pool()
for p in mock_nba_pool:
if p.name == 'A1':
# A1 normally would always be in the lineup
# due to highest projection among PGs
p.proj = 502
if p.name == 'A4':
# A4 projection is so negative it should
# never be in any lineup
p.proj = -1_000_000
roster = run(
rule_set=rules.DK_NBA_RULE_SET,
player_pool=mock_nba_pool,
verbose=True,
optimizer_settings=settings,
)
names = {p.name for p in roster.players}
ntools.assert_equal(True, 'A1' not in names and 'A4' not in names)
def test_multi_roster_nfl():
players = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
projection_file_location=projection_file,
game=rules.DRAFT_KINGS,
)
roster = run(rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
verbose=True)
second_roster = run(rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
optimizer_settings=OptimizerSettings(
existing_rosters=[roster], ),
verbose=True)
ntools.assert_not_equal(roster, None)
ntools.assert_not_equal(second_roster, None)
ntools.assert_false(roster.exact_equal(second_roster))
def test_team_rules():
mock_nba_pool = construct_pool()
# If two PGs on one team, play the C from same team
settings = OptimizerSettings(custom_rules=[
CustomRule(
group_a=lambda p: p.pos == 'C' and p.team == 'SomeTeam',
group_b=lambda p: p.pos == 'PG' and p.team == 'SomeTeam',
)
])
roster = run(
rule_set=rules.DK_NBA_RULE_SET,
player_pool=mock_nba_pool,
verbose=True,
optimizer_settings=settings,
)
names = {p.name for p in roster.players}
ntools.assert_equal(True, 'A100' in names and 'A101' in names
and 'A10' in names)
def test_te_combo():
players = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
projection_file_location=projection_file,
game=rules.DRAFT_KINGS,
)
roster = run(rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
optimizer_settings=OptimizerSettings(
force_combo=True,
combo_allow_te=True,
))
qb = roster.sorted_players()[0]
ntools.assert_equal(qb.pos, 'QB')
team_count = len([
x for x in roster.sorted_players()
if x.team == qb.team and x.pos == 'TE'
])
ntools.assert_equals(team_count, 1)
def __init__(
self,
players,
rule_set,
settings,
):
settings = settings or OptimizerSettings()
self.solver = pywraplp.Solver(
'FD',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING
)
self.players = players
self.enumerated_players = list(enumerate(players))
self.existing_rosters = settings.existing_rosters or []
self.salary_min = rule_set.salary_min
self.salary_max = rule_set.salary_max
self.roster_size = rule_set.roster_size
self.position_limits = rule_set.position_limits
self.offensive_positions = rule_set.offensive_positions
self.defensive_positions = rule_set.defensive_positions
self.general_position_limits = rule_set.general_position_limits
self.settings = settings
self.player_to_idx_map = {}
self.variables = []
for idx, player in self.enumerated_players:
if player.lock and not player.multi_position:
self.variables.append(
self.solver.IntVar(
1, 1, player.solver_id
)
)
else:
self.variables.append(
self.solver.IntVar(0, 1, player.solver_id)
)
self.player_to_idx_map[player.solver_id] = idx
self.objective = self.solver.Objective()
self.objective.SetMaximization()
def test_impossible_constraints():
players = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
projection_file_location=projection_file,
game=rules.DRAFT_KINGS,
)
roster = run(rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
optimizer_settings=OptimizerSettings(
stacks=[Stack(team='NE', count=100)],
no_offense_against_defense=True),
constraints=LineupConstraints(
banned=['Sammy Watkins', 'Kellen Davis'],
locked=['Spencer Ware'],
groups=[[('Philip Rivers', 'Sam Bradford', 'Andrew Luck'),
2],
[('Saints', 'Alshon Jeffery', 'Lamar Miller'),
(1, 3)]]),
verbose=True)
ntools.assert_equal(roster, None)
def test_triple_stack():
player_pool = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
game=rules.DRAFT_KINGS,
ruleset=rules.DK_NHL_RULE_SET,
)
roster = run(rule_set=rules.DK_NHL_RULE_SET,
player_pool=player_pool,
verbose=True,
optimizer_settings=OptimizerSettings(stacks=[
Stack(team='TOR', count=3),
Stack(team='COL', count=3),
Stack(team='VAN', count=2),
]))
players = roster.sorted_players()
phi_players = [x for x in players if x.team == 'TOR']
fla_players = [x for x in players if x.team == 'COL']
nsh_players = [x for x in players if x.team == 'VAN']
ntools.assert_equal(len(phi_players), 3)
ntools.assert_equal(len(fla_players), 3)
ntools.assert_equal(len(nsh_players), 2)