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 optimize(all_players: list,
player_settings: PlayerPoolSettings = PlayerPoolSettings(),
constraints: LineupConstraints = LineupConstraints()):
lineup_players = []
all_players = list(
filter(add_pickem_contraints(player_settings), all_players))
if constraints.has_group_constraints():
raise NotImplementedError('Groups are not supported for pickem')
for p in all_players:
if constraints.is_banned(p.name):
p.ban = True
for t in TIERS:
best = sorted(
[p for p in all_players if p.tier == t and not p.ban],
key=lambda p: p.proj,
reverse=True,
)[0]
lineup_players.append(best)
lineup = TieredLineup(lineup_players)
for p in all_players:
if constraints.is_locked(p.name):
p.lock = True
setattr(lineup, p.tier, p)
return lineup
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_build_constraint_set():
lcs = LineupConstraints()
lcs.add_group_constraint(['Spencer Ware', 'Amari Cooper'], 1)
lcs.ban(['Packers'])
lcs.add_group_constraint(['Eli Manning', 'Russell Wilson', 'Doug Martin'],
(1, 3))
lcs.lock(['Will Fuller'])
ntools.assert_equal(len(lcs), 4)
def test_constraint_contains():
lcs = LineupConstraints()
lcs.add_group_constraint(['A', 'B'], 1)
lcs.ban(['C'])
lcs.add_group_constraint(['E', 'F', 'G'], (1, 3))
lcs.lock(['H'])
for c in ['A', 'B', 'C', 'E', 'F', 'G', 'H']:
ntools.assert_equal(c in lcs, True)
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_banned_players():
players = _generate_test_player_data()
optimized = optimize(players,
player_settings=PlayerPoolSettings(),
constraints=LineupConstraints(banned=['A', 'C']))
ntools.assert_equal(optimized.total, 49 + 47 + 46 + 44 + 42 + 40)
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_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_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_position():
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,
constraints=LineupConstraints(locked=['Eli Manning'], ),
verbose=True)
ntools.assert_not_equal(roster, None)
multi_pos = [p for p in roster.players if p.name == 'Eli Manning']
ntools.assert_equal(len(multi_pos), 1)
ntools.assert_equal(multi_pos[0].pos, 'TE')
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_respect_ban():
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,
constraints=LineupConstraints(banned=['Eli Manning'], ),
)
for player in roster.sorted_players():
ntools.assert_not_equal(player.name, 'Eli Manning')
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_respect_lock():
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,
constraints=LineupConstraints(locked=['Andrew Luck'], ),
)
qb = roster.sorted_players()[0]
ntools.assert_equal(qb.pos, 'QB')
ntools.assert_equal(qb.name, 'Andrew Luck')
def test_respect_group1():
players = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
projection_file_location=projection_file,
game=rules.DRAFT_KINGS,
)
grouped_players = ('DeAndre Hopkins', 'Amari Cooper', 'Sammy Watkins')
roster = run(
rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
verbose=True,
constraints=LineupConstraints(groups=[[grouped_players, 2]], ),
)
group_count = len(
[x for x in roster.sorted_players() if x.name in grouped_players])
ntools.assert_equal(group_count, 2)
def test_multi_position_group_constraint2():
players = salary_download.generate_players_from_csvs(
salary_file_location=salary_file,
projection_file_location=projection_file,
game=rules.DRAFT_KINGS,
)
grouped_players = ('Eli Manning', 'Dez Bryant', 'Geno Smith')
roster = run(rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
constraints=LineupConstraints(groups=[
[grouped_players, 2],
]),
verbose=True)
group_count = len(
[x for x in roster.sorted_players() if x.name in grouped_players])
ntools.assert_equal(group_count, 2)
ntools.assert_equal(roster.projected(), 120.89999999999999)
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_multi_position_group_constraint():
players = [
Player(name='A',
cost=5500,
proj=400,
pos='QB',
possible_positions='QB/WR',
multi_position=True),
Player(name='A',
cost=5500,
proj=400,
pos='WR',
possible_positions='QB/WR',
multi_position=True),
Player(name='B', cost=5500, proj=41, pos='QB'),
Player(name='C',
cost=5500,
proj=500,
pos='WR',
possible_positions='RB/WR',
multi_position=True),
Player(name='C',
cost=5500,
proj=500,
pos='RB',
possible_positions='RB/WR',
multi_position=True),
Player(name='D', cost=5500, proj=42, pos='WR'),
Player(name='E', cost=5500, proj=43, pos='WR'),
Player(name='F', cost=5500, proj=44, pos='WR'),
Player(name='G', cost=5500, proj=45, pos='RB'),
Player(name='H', cost=5500, proj=46, pos='RB'),
Player(name='I', cost=5500, proj=47, pos='RB'),
Player(name='J',
cost=5500,
proj=480,
pos='TE',
possible_positions='TE/WR',
multi_position=True),
Player(name='J',
cost=5500,
proj=480,
pos='WR',
possible_positions='TE/WR',
multi_position=True),
Player(name='K', cost=5500, proj=49, pos='TE'),
Player(name='L', cost=5500, proj=51, pos='DST'),
Player(name='M', cost=5500, proj=52, pos='DST'),
]
grouped_players = ('A', 'C', 'J')
roster = run(rule_set=rules.DK_NFL_RULE_SET,
player_pool=players,
constraints=LineupConstraints(groups=[
[grouped_players, 2],
]),
verbose=True)
group_count = len(
[x for x in roster.sorted_players() if x.name in grouped_players])
ntools.assert_equal(group_count, 2)
ntools.assert_equal(roster.projected(), 1304)
def test_constraint_string_args():
lcs = LineupConstraints()
lcs.ban('Sam Bradford')
lcs.lock('Will Fuller')
ntools.assert_equal(len(lcs), 2)
def test_locked_players():
players = _generate_test_player_data()
optimized = optimize(players,
constraints=LineupConstraints(locked=['B', 'D']))
ntools.assert_equal(optimized.total, 49 + 47 + 46 + 44 + 42 + 40)
def optimizeJSON(payload):
raw = pd.read_json((payload["raw"]))
data = pd.read_json((payload["posted"]))
optimizer = None
if (payload["site"] == "DRAFTKINGS"):
if (payload["sport_type"] == "PGA"):
optimizer = get_optimizer(Site.DRAFTKINGS, Sport.GOLF)
elif (payload["sport_type"] == "NFL"):
optimizer = get_optimizer(Site.DRAFTKINGS, Sport.FOOTBALL)
else:
optimizer = get_optimizer(Site.DRAFTKINGS, Sport.BASKETBALL)
raw['AvgPointsPerGame'] = raw[payload["projection"]]
raw['AvgPointsPerGame'] = pd.to_numeric(raw["AvgPointsPerGame"]).fillna(0)
else:
if (payload["sport_type"] != "PGA"):
optimizer = get_optimizer(Site.FANDUEL, Sport.FOOTBALL)
if (payload["sport_type"] == "NBA"):
optimizer = get_optimizer(Site.FANDUEL, Sport.BASKETBALL)
raw['FPPG'] = raw[payload["projection"]]
raw['FPPG'] = pd.to_numeric(raw["FPPG"]).fillna(0)
raw['First Name'] = raw['Name']
raw['Last Name'] = raw['Name']
raw['Nickname'] = raw['Name']
raw["Injury Indicator"] = ""
raw['Team'] = raw['TeamAbbrev']
# if os.path.exists("lineup.csv"):
# os.remove("lineup.csv")
lineup_writer = open('/home/johnh/lineup.csv', 'w+')
lineup_writer.close()
raw.to_csv("/home/johnh/lineup.csv")
del raw
if payload["site"] == "FANDUEL" and payload["sport_type"] == "PGA":
players = salary_download.generate_players_from_csvs(
salary_file_location='/home/johnh/lineup.csv',
game=rules.FAN_DUEL,
)
iterations=payload["lineups"]
index = 0
exposure_players = []
locked = []
removed = []
for r in data["Name"]:
if (data["Lock"][index] == 0) and (data["Remove"][index] == 0):
exp_player = {}
exp_player["name"] = r
exp_player["min"] = 0.1
exp_player["max"] = data["Exposure"][index] / 100.0
exposure_players.append(exp_player)
if (data["Lock"][index] == 1) and (data["Remove"][index] == 0):
locked.append(data["Name"][index])
if (data["Lock"][index] == 0) and (data["Remove"][index] == 1):
removed.append(data["Name"][index])
index = index + 1
rosters, exposure_diffs = run_multi(
iterations=iterations,
rule_set=rules.FD_PGA_RULE_SET,
player_pool=players,
exposure_bounds=exposure_players,
constraints=LineupConstraints(
locked=locked,
banned=removed
)
)
ntools.assert_equal(len(rosters), iterations)
ntools.assert_equal(len(exposure_diffs), 0)
lineups = []
exports = []
exports.append(["G","G","G","G","G","G","Budget","FPPG"])
for r in rosters:
export = []
for p in r.sorted_players():
lineup = []
lineup.append("G")
lineup.append(p.name)
lineup.append(p.team)
lineup.append(p.proj)
lineup.append(p.cost)
lineups.append(lineup)
name_index = list(data["Name"]).index(p.name)
export.append(data["ID"][name_index] + ":" + p.name)
total = ["", "", ""]
total.append("{0:.2f}".format(round(r.projected(),2)))
total.append(r.spent())
lineups.append(total)
exports.append(export)
del lineups
del exports
del total
del iterations
del exposure_players
del locked
del removed
result = {"lineups": lineups,
"export": exports}
return result
optimizer.load_players_from_csv("/home/johnh/lineup.csv")
# advanced options (lock, remove and exposure)
for index, row in data.iterrows():
if (row['Remove'] == 1):
print("Removing player: " + row['Name'], row['Remove'])
player = optimizer.get_player_by_id(row['ID'])
optimizer.remove_player(player)
if (row['Lock'] == 1):
print("Lock player: " + row['Name'], row['Remove'])
player = optimizer.get_player_by_id(row['ID'])
optimizer.add_player_to_lineup(player)
if ((row['Exposure'] >= 0) and (row['Exposure'] < 100)):
#print("Set exposure : " + row['Name'], row['Exposure'] / 100.0)
player = optimizer.get_player_by_id(row['ID'])
#print(player)
player.max_exposure = row['Exposure'] / 100.0
if (payload["sport_type"] == "NFL") and (payload["site"] == "DRAFTKINGS"):
optimizer.set_min_salary_cap(49500)
lineupGenerator = optimizer.optimize(payload["lineups"])
def render_player(player):
# type: (LineupPlayer) -> str
result = player.full_name
#print player.id
if player.id:
# if payload["site"] == "FANDUEL" and payload["sport_type"] == "NFL":
# result = player.id + ":" + result
# else:
result += '(%s)' % player.id
return result
rows = []
header = None
print(lineupGenerator)
for index, lineup in enumerate(lineupGenerator):
if index == 0:
header = [player.lineup_position for player in lineup.lineup]
header.extend(('Budget', 'FPPG'))
row = [(render_player)(player) for player in lineup.lineup]
row.append(str(lineup.salary_costs))
row.append(str(lineup.fantasy_points_projection))
rows.append(row)
data = pd.DataFrame.from_records(rows, columns = header)
lineups = pd.DataFrame()
names = []
positions = []
teams = []
fppgs = []
salaries = []
# add number to duplicate cols
def rename_duplicates(old):
new = []
seen = {}
for x in old:
if x in seen:
seen[x] += 1
new.append( "%s_%d" % (x, seen[x]))
else:
seen[x] = 0
new.append(x)
return new
data.columns = rename_duplicates(list(data.columns))
for index, row in data.iterrows():
for player in data.columns[:-2]:
playerName = row[player].split("(")[0]
names.append(playerName)
positions.append(player)
player = optimizer.get_player_by_name(playerName)
fppgs.append(player.fppg)
teams.append(player.team)
salaries.append(player.salary)
positions.append("Totals")
names.append("")
teams.append("")
fppgs.append(row["FPPG"])
salaries.append(row["Budget"])
positions.append("")
names.append("")
teams.append("")
fppgs.append("")
salaries.append("")
# print row["PG"]
lineups["Positions"] = positions
lineups["Name"] = names
lineups["Team"] = teams
lineups["Projection"] = fppgs
lineups["salaries"] = salaries
result = {"lineups": lineups.values.tolist(),
"export": [list(data.columns)] + data.values.tolist()}
del payload
return jsonify(result)
def run(rule_set: RuleSet,
player_pool: list,
constraints: LineupConstraints = LineupConstraints(),
optimizer_settings: OptimizerSettings = OptimizerSettings(),
player_settings: PlayerPoolSettings = PlayerPoolSettings(),
exposure_dict: dict = dict(),
roster_gen: Roster = None,
verbose=False) -> Roster:
players = player_pool
if player_settings.exist() or constraints.exist():
players = pool.filter_pool(
deepcopy(player_pool),
player_settings,
)
if not isinstance(rule_set, RuleSet):
raise Exception("RuleSet not defined. Please refer to the docs")
if rule_set.game_type == 'showdown':
if optimizer_settings.no_offense_against_defense:
print('WARNING:')
print('no_offense_against_defense setting ignored for showdown')
print('game types. Use no_defense_against_captain instead.')
print()
optimizer = Optimizer(
players=players,
rule_set=rule_set,
settings=optimizer_settings,
lineup_constraints=constraints,
exposure_dict=exposure_dict,
)
variables = optimizer.variables
if optimizer.solve():
if roster_gen:
roster = roster_gen()
else:
roster = RosterSelect().roster_gen(rule_set.league)
for i, player in enumerate(players):
if variables[i].solution_value() == 1:
roster.add_player(player)
if verbose:
print('Optimal roster for: {}'.format(rule_set.league))
print(roster)
return roster
if verbose:
print('''
No solution found.
Try adjusting your query by taking away constraints.
OPTIMIZER CONSTRAINTS:
{}
LINEUP CONSTRAINTS:
{}
PLAYER POOL SETTINGS:
{}
PLAYER COUNT: {}
'''.format(optimizer_settings, constraints, player_settings,
len(players or [])))
return None
def test_dup_group_rule2():
lcs = LineupConstraints()
lcs.add_group_constraint(['Eli Manning', 'Russell Wilson', 'Doug Martin'],
(1, 2))
lcs.add_group_constraint(['Eli Manning', 'Russell Wilson', 'Doug Martin'],
(1, 2))
def test_bad_group_shadow_ban_hi_lo_bound():
lcs = LineupConstraints()
lcs.add_group_constraint(['Spencer Ware', 'Amari Cooper'], (0, 0))
import os
import random
from draftfast.pickem.pickem_optimize import optimize
from draftfast.csv_parse import uploaders, salary_download
from draftfast import rules
from draftfast.lineup_constraints import LineupConstraints
salary_file_location = os.environ.get('PICKEM')
pid_file_location = os.environ.get('PICKEM_PIDS')
players = salary_download.generate_players_from_csvs(
game=rules.DRAFT_KINGS,
salary_file_location=salary_file_location,
ruleset=rules.DK_NBA_PICKEM_RULE_SET,
)
rosters = []
for p in range(20):
player = random.choice(players)
roster = optimize(
all_players=players,
constraints=LineupConstraints(locked=[p.name]),
)
rosters.append(roster)
uploader = uploaders.DraftKingsNBAPickemUploader(pid_file=pid_file_location, )
uploader.write_rosters(rosters)
def test_bad_group_duplicate_bounds():
lcs = LineupConstraints()
lcs.add_group_constraint(['Spencer Ware', 'Amari Cooper'], (1, 1))