def setUp(self):
self.players = [
Player('1', 'Golf Player 1', '', [
'G'], '', 5000, 200, projected_ownership=0.95),
Player('2', 'Golf Player 2', '', [
'G'], '', 5000, 20, projected_ownership=0.7),
Player('3', 'Golf Player 3', '', [
'G'], '', 5000, 20, projected_ownership=0.7),
Player('4', 'Golf Player 4', '', [
'G'], '', 5000, 20, projected_ownership=0.7),
Player('5', 'Golf Player 5', '', [
'G'], '', 5000, 5, projected_ownership=0.5),
Player('6', 'Golf Player 6', '', [
'G'], '', 5000, 5, projected_ownership=0.5),
Player('7', 'Golf Player 7', '', [
'G'], '', 5000, 5, projected_ownership=0.5),
Player('8', 'Golf Player 8', '', [
'G'], '', 5000, 5, projected_ownership=0.5),
Player('9', 'Golf Player 9', '', [
'G'], '', 5000, 5, projected_ownership=0.5),
Player('10', 'Golf Player 10', '', [
'G'], '', 5000, 5, projected_ownership=0.5),
]
self.optimizer = get_optimizer(Site.DRAFTKINGS, Sport.GOLF)
self.optimizer.load_players(self.players)
def setUp(self):
self.players = load_players()
self.optimizer = get_optimizer(Site.DRAFTKINGS, Sport.BASKETBALL)
self.optimizer.settings.max_from_one_team = 4
self.test_team = 'TEST'
self.spacing_players = [
Player('1',
'1',
'1', ['PG'],
self.test_team,
100,
40,
roster_order=1),
Player('2',
'2',
'2', ['SG'],
self.test_team,
100,
30,
roster_order=2),
Player('3',
'3',
'3', ['SF'],
self.test_team,
100,
50,
roster_order=3),
]
self.optimizer.load_players(self.players + self.spacing_players)
def test_max_from_one_team(self):
max_from_one_team = 1
optimizer = self.lineup_optimizer
players = [
Player(1, 'p1', 'p1', ['PG', 'SG'], 'DEN', 10, 200),
Player(2, 'p2', 'p2', ['PF', 'SF'], 'DEN', 10, 200),
Player(3, 'p3', 'p3', ['C'], 'DEN', 10, 200),
]
optimizer.extend_players(players)
with mock.patch('pydfs_lineup_optimizer.LineupOptimizer.max_from_one_team', new_callable=mock.PropertyMock) \
as mock_max_from_one_team:
mock_max_from_one_team.return_value = max_from_one_team
lineup = next(optimizer.optimize(1))
team_counter = Counter([p.team for p in lineup.lineup])
self.assertTrue(
all([
team_players <= max_from_one_team
for team_players in team_counter.values()
]))
with self.assertRaises(LineupOptimizerException):
self.lineup_optimizer.set_players_from_one_team({'DEN': 3})
next(optimizer.optimize(1))
optimizer.add_player_to_lineup(players[0])
with self.assertRaises(LineupOptimizerException):
optimizer.add_player_to_lineup(players[1])
def test_remove_player_from_lineup(self):
self.lineup_optimizer.reset_lineup()
players = [
Player('', 'P', 'P', ['PG'], 'DEN', 10, 2),
Player('', 'C', 'C', ['PG'], 'DEN', 10, 2),
Player('', 'P', 'P', ['PG'], 'DEN', 10, 2),
]
self.lineup_optimizer._players.extend(players)
self.lineup_optimizer.add_player_to_lineup(players[0])
self.lineup_optimizer.remove_player_from_lineup(players[0])
self.assertEqual(len(self.lineup_optimizer._lineup), 0)
self.lineup_optimizer.add_player_to_lineup(players[0])
self.lineup_optimizer.add_player_to_lineup(players[1])
self.lineup_optimizer.add_player_to_lineup(players[2])
self.assertEqual(self.lineup_optimizer._positions[('PG',)].min, 0)
self.assertEqual(self.lineup_optimizer._positions[('PG',)].max, 0)
self.assertEqual(self.lineup_optimizer._positions[('PG', 'SG')].min, 0)
self.assertEqual(self.lineup_optimizer._positions[('PG', 'SG')].max, 1)
self.lineup_optimizer.remove_player_from_lineup(players[0])
self.assertEqual(self.lineup_optimizer._positions[('PG', )].min, 0)
self.assertEqual(self.lineup_optimizer._positions[('PG', )].max, 1)
self.assertEqual(self.lineup_optimizer._positions[('PG', 'SG')].min, 1)
self.assertEqual(self.lineup_optimizer._positions[('PG', 'SG')].max, 2)
self.lineup_optimizer.remove_player_from_lineup(players[1])
self.assertEqual(self.lineup_optimizer._positions[('PG', )].min, 0)
self.assertEqual(self.lineup_optimizer._positions[('PG', )].max, 2)
self.assertEqual(self.lineup_optimizer._positions[('PG', 'SG')].min, 2)
self.assertEqual(self.lineup_optimizer._positions[('PG', 'SG')].max, 3)
self.lineup_optimizer.remove_player_from_lineup(players[2])
self.assertEqual(self.lineup_optimizer._positions[('PG', )].min, 1)
self.assertEqual(self.lineup_optimizer._positions[('PG', )].max, 3)
self.assertEqual(self.lineup_optimizer._positions[('PG', 'SG')].min, 3)
self.assertEqual(self.lineup_optimizer._positions[('PG', 'SG')].max, 4)
def setUp(self):
self.players = load_players()
self.starters = [
Player('1', '1', '1', ['PG', 'SG'], '1', 1000, 0, is_confirmed_starter=True),
Player('2', '2', '2', ['SF', 'PF'], '2', 1000, 0, is_confirmed_starter=True),
]
self.lineup_optimizer = get_optimizer(Site.DRAFTKINGS, Sport.BASKETBALL)
self.lineup_optimizer.player_pool.load_players(self.players + self.starters)
def test_standard_strategy(self):
player1 = Player('1', '1', '1', ['P'], 'test', 5000, 20)
player2 = Player('2', '2', '2', ['P'], 'test', 8000, 30)
strategy = StandardFantasyPointsStrategy()
self.assertEqual(strategy.get_player_fantasy_points(player1), 20)
self.assertEqual(strategy.get_player_fantasy_points(player2), 30)
strategy.set_previous_lineup(Lineup([LineupPlayer(player1, 'P')]))
self.assertEqual(strategy.get_player_fantasy_points(player1), 20)
self.assertEqual(strategy.get_player_fantasy_points(player2), 30)
def test_lineup_with_players_from_same_positions(self):
self.lineup_optimizer.reset_lineup()
self.lineup_optimizer._players.extend([
Player('', 'p1', 'p1', ['C'], 'DEN', 10, 2),
Player('', 'p2', 'p2', ['C'], 'DEN', 10, 2),
])
self.lineup_optimizer.set_players_with_same_position({'C': 1})
lineup = next(self.lineup_optimizer.optimize(1))
self.assertTrue(len(list(filter(lambda x: 'C' in x.positions, lineup.lineup))) >= 2)
def setUp(self):
self.players = load_players()
self.players_with_min_exposure = [
Player('1', '1', '1', ['PG', 'SG'], '1', 1000, 0, min_exposure=0.3),
Player('2', '2', '2', ['SF', 'PF'], '2', 1000, 0, min_exposure=0.35),
Player('3', '3', '3', ['C'], '3', 1000, 0, min_exposure=0.95),
Player('4', '4', '4', ['C'], '4', 1000, 0, min_exposure=0.93),
]
self.lineup_optimizer = get_optimizer(Site.DRAFTKINGS, Sport.BASKETBALL)
self.lineup_optimizer.player_pool.load_players(self.players + self.players_with_min_exposure)
def setUp(self):
self.players = load_players()
self.player_with_max_exposure = [
Player('1',
'p1',
'p1', ['PG', 'SG'],
'DEN',
10,
200,
max_exposure=0.3),
Player('2', 'p2', 'p2', ['PF', 'SF'], 'DEN', 10, 200),
Player('3', 'p3', 'p3', ['C'], 'DEN', 100, 2, max_exposure=0.35),
Player('4', 'p4', 'p4', ['PG'], 'DEN', 100, 2),
Player('5', 'p5', 'p5', ['PF'], 'DEN', 100, 2, max_exposure=0),
Player('6', 'p6', 'p6', ['SF'], 'DEN', 1, 2001, max_exposure=0),
]
self.players_with_min_exposure = [
Player('7',
'p7',
'p7', ['PG', 'SG'],
'SAS',
1000,
0,
min_exposure=0.3),
Player('8', 'p8', 'p8', ['C'], 'SAS', 1000, 0, min_exposure=0.35),
Player('9', 'p9', 'p9', ['C'], 'SAS', 1000, 0, min_exposure=1),
]
self.lineup_optimizer = get_optimizer(Site.DRAFTKINGS,
Sport.BASKETBALL)
self.lineup_optimizer.load_players(self.players)
def setUp(self):
self.players = load_players()
self.test_team = 'TEST'
self.high_fppg_players = [
Player('1', '1', '1', ['PG'], self.test_team, 3000, 100),
Player('2', '2', '2', ['SG'], self.test_team, 3000, 100),
Player('3', '3', '3', ['SF'], self.test_team, 3000, 100),
]
self.high_fppg_players_positions = ['PG', 'SG', 'SF']
self.optimizer = get_optimizer(Site.DRAFTKINGS, Sport.BASKETBALL)
self.optimizer.load_players(self.players + self.high_fppg_players)
def setUp(self):
self.players = load_players()
self.first_team = 'TEST 1'
self.second_team = 'TEST 2'
self.high_fppg_players = [
Player('1', '1', '1', ['PG'], self.first_team, 3000, 100),
Player('2', '2', '2', ['SG'], self.first_team, 3000, 100),
Player('3', '3', '3', ['SF'], self.second_team, 3000, 100),
Player('3', '3', '3', ['PF'], self.second_team, 3000, 100),
]
self.optimizer = get_optimizer(Site.DRAFTKINGS, Sport.BASKETBALL)
self.optimizer.load_players(self.players + self.high_fppg_players)
def setUp(self):
self.players = load_players()
self.group = [
Player('1', '1', '1', ['PG'], '1', 3000, 1),
Player('2', '2', '2', ['SG'], '2', 3000, 1),
]
self.high_fppg_group = [
Player('3', '3', '3', ['SF'], '3', 30, 100),
Player('4', '4', '4', ['PF'], '4', 30, 100),
]
self.optimizer = get_optimizer(Site.DRAFTKINGS, Sport.BASKETBALL)
self.optimizer.load_players(self.players + self.group + self.high_fppg_group)
def setUp(self):
self.players = load_players()
self.first_team = 'TEST 1'
self.second_team = 'TEST 2'
self.game_info = GameInfo(self.first_team, self.second_team, datetime.now(), False)
self.extra_players = [
Player('1', '1', '1', ['PG'], self.first_team, 3000, 100, game_info=self.game_info),
Player('2', '2', '2', ['SG'], self.first_team, 3000, 100, game_info=self.game_info),
Player('3', '3', '3', ['SF'], self.second_team, 3000, 1, game_info=self.game_info),
Player('4', '4', '4', ['PF'], self.second_team, 3000, 1, game_info=self.game_info),
]
self.optimizer = get_optimizer(Site.DRAFTKINGS, Sport.BASKETBALL)
self.optimizer.load_players(self.players + self.extra_players)
def test_lineup_with_players_from_same_positions(self):
optimizer = get_optimizer(Site.DRAFTKINGS, Sport.BASKETBALL)
optimizer.load_players(
create_players(['PG', 'SG', 'SF', 'PF', 'C', 'PG', 'SF', 'PF']))
optimizer.extend_players([
Player(1, 'p1', 'p1', ['C'], 'DEN', 1000, 2),
Player(2, 'p2', 'p2', ['C'], 'DEN', 1000, 2),
])
optimizer.set_players_with_same_position({'C': 1})
lineup = next(optimizer.optimize(1))
self.assertTrue(
len(list(filter(lambda x: 'C' in x.positions, lineup.lineup))) >= 2
)
def setUp(self):
self.small_salary_player = Player('1', 'p1', 'p1', ['PG'], 'team1', 1, 200)
self.players = load_players()
self.players.append(self.small_salary_player)
self.lineup_optimizer = get_optimizer(Site.DRAFTKINGS, Sport.BASKETBALL)
self.lineup_optimizer.load_players(self.players)
self.min_salary_cap = self.lineup_optimizer.settings.budget
def import_players(self):
games = {} # type: Dict[Tuple[str, str], GameInfo]
players = []
with open(self.filename, 'r') as csvfile:
csv_data = csv.DictReader(csvfile, skipinitialspace=True)
for row in csv_data:
player_id = self._process_cell(row['ID'])
if not player_id:
continue
try:
away_team, home_team = self._process_cell(
row.get('Game', '')).split('@')
game_info = games.get((home_team, away_team), None)
if not game_info:
game_info = GameInfo(home_team, away_team, None)
games[(home_team, away_team)] = game_info
except ValueError:
game_info = None
try:
player = Player(
player_id,
self._process_cell(row['First Name']),
self._process_cell(row['Last Name']),
self._process_cell(row['Position']).split('/'),
self._process_cell(row['Team']),
float(self._process_cell(row['Salary'])),
float(self._process_cell(row['FPPG'])),
is_injured=True
if self._process_cell(row['Injury Status']) else False,
game_info=game_info,
**self.get_player_extra(row))
except KeyError:
raise LineupOptimizerIncorrectCSV
players.append(player)
return players
def import_players(self):
players = []
i = 0
with open(self.filename, 'r') as csvfile:
csv_data = csv.DictReader(csvfile, skipinitialspace=True)
for row in csv_data:
game_info = None
try:
home_team = row["HomeTeam"]
away_team = row["AwayTeam"]
game_info = GameInfo(home_team, away_team, None, False)
except ValueError:
pass
try:
player = Player(row['Player ID'],
row['Name'].split(" ")[0],
row['Name'].split(" ")[1],
[row['Position']] if not row['Position2']
else [row['Position'], row['Position2']],
row['Team'],
float(row['Price']),
float(row['Projection']),
max_exposure=float(row['Max Exposure']),
game_info=game_info)
except KeyError:
raise LineupOptimizerIncorrectCSV
i = i + 1
players.append(player)
return players
def import_players(self): # pragma: no cover
players = []
with open(self.filename, 'r') as csvfile:
csv_data = csv.DictReader(csvfile, skipinitialspace=True)
for i, row in enumerate(csv_data):
try:
name = row['Name'].split()
max_exposure = row.get('Max Exposure')
fppg = row.get('Avg FPPG') or row.get('Avg FPPT')
if not fppg:
raise LineupOptimizerIncorrectCSV
player = Player(
i,
name[0],
name[1] if len(name) > 1 else '',
row['Position'].split('/'),
row.get('Team') or row.get('Game', ''),
float(row['Salary'].replace('$', '').replace(',', '')),
float(fppg),
max_exposure=float(max_exposure.replace('%', ''))
if max_exposure else None)
except KeyError:
raise LineupOptimizerIncorrectCSV
players.append(player)
return players
def import_players(self):
players = []
with open(self.filename, 'r') as csvfile:
csv_data = csv.DictReader(csvfile, skipinitialspace=True)
for row in csv_data:
game_info = None
try:
away_team, home_team = row.get('Game', '').split('@')
game_info = GameInfo(home_team, away_team, None, False)
except ValueError:
pass
try:
max_exposure = row.get('Max Exposure')
player = Player(
row['Id'],
row['First Name'],
row['Last Name'],
row['Position'].split('/'),
row['Team'],
float(row['Salary']),
float(row['FPPG']),
True if row['Injury Indicator'].strip() else False,
max_exposure=float(max_exposure.replace('%', ''))
if max_exposure else None,
game_info=game_info,
)
except KeyError:
raise LineupOptimizerIncorrectCSV
players.append(player)
return players
def import_players(self):
players = []
with open(self.filename, 'r') as csvfile:
csv_data = csv.DictReader(csvfile, skipinitialspace=True)
for row in csv_data:
game_info = None
try:
away_team, home_team = row.get('Game', '').split('@')
game_info = GameInfo(home_team, away_team, None, False)
except ValueError:
pass
try:
player = Player(row['ID'],
row['First Name'],
row['Last Name'],
row['Position'].split('/'),
row['Team'],
float(row['Salary']),
float(row['FPPG']),
is_injured=True
if row['Injury Status'].strip() else False,
game_info=game_info,
**self.get_player_extra(row))
except KeyError:
raise LineupOptimizerIncorrectCSV
players.append(player)
return players
def create_players(positions_list):
players = []
for i, positions in enumerate(positions_list):
players.append(
Player(player_id=i, first_name=i, last_name=i, positions=positions.split('/'), team=str(i),
salary=10, fppg=10)
)
return players
def test_roster_spacing_correctness_cyclic(self):
self.optimizer.set_spacing_for_positions(self.positions, 3)
player = Player('14', '14', '14', ['1B'], 'NY', 3000, 50, roster_order=1)
self.optimizer.player_pool.extend_players([player])
lineup = next(self.optimizer.optimize(1))
self.assertIn(player, lineup)
self.assertIn(self.players_dict['12'], lineup)
self.assertIn(self.players_dict['13'], lineup)
def test_with_injured_optimize(self):
optimizer = self.lineup_optimizer
cool_player = Player('1', 'P1', 'P1', ['PG'], 'team1', 1, 200, is_injured=True)
optimizer.extend_players([cool_player])
lineup = next(optimizer.optimize(1))
self.assertNotIn(cool_player, lineup)
lineup = next(optimizer.optimize(1, with_injured=True))
self.assertIn(cool_player, lineup)
def test_unique_player_rule(self):
optimizer = get_optimizer(Site.DRAFTKINGS, Sport.GOLF)
players = create_players(['G'] * 10)
high_fppg_player = Player('1', 'High FPPG', 'Player', ['G'], '', 50, 200)
players.extend([high_fppg_player] * 2)
optimizer.load_players(players)
lineup = next(optimizer.optimize(1))
self.assertEqual(len([p for p in lineup if p == high_fppg_player]), 1)
def test_lineup_with_players_from_same_positions(self):
self.lineup_optimizer.load_players(create_players(['PG', 'SG', 'SF', 'PF', 'C', 'PG', 'SF', 'PF']))
self.lineup_optimizer.extend_players([
Player('1', 'p1', 'p1', ['C'], 'DEN', 1000, 2), # Shouldn't be in lineup because of small efficiency
])
self.lineup_optimizer.set_players_with_same_position({'C': 1})
lineup = next(self.lineup_optimizer.optimize(1))
self.assertTrue(len(list(filter(lambda x: 'C' in x.positions, lineup.lineup))) >= 2)
def setUp(self):
self.flex_players = [
Player('1', '1', '1', ['QB'], 'HOU', 3000, 30),
Player('2', '2', '2', ['QB'], 'BOS', 3000, 30),
Player('3', '3', '3', ['TE'], 'BOS', 3000, 10),
Player('4', '4', '4', ['WR'], 'HOU', 3000, 15),
Player('5', '5', '5', ['RB'], 'HOU', 3000, 20),
]
self.mvp_players = []
for player in self.flex_players:
mvp = deepcopy(player)
mvp.is_mvp = True
mvp.fppg *= 1.5
self.mvp_players.append(mvp)
self.all_players = self.flex_players + self.mvp_players
self.optimizer = get_optimizer(Site.FANDUEL_SINGLE_GAME, Sport.FOOTBALL)
self.optimizer.load_players(self.all_players)
def test_add_player_with_many_positions(self):
players = [
Player('', 'p1', 'p1', ['PG', 'SG'], 'DEN', 10, 200),
Player('', 'p2', 'p2', ['PG'], 'DEN', 10, 200),
Player('', 'p3', 'p3', ['PG'], 'DEN', 10, 200),
Player('', 'p4', 'p4', ['PG'], 'DEN', 10, 200),
Player('', 'p5', 'p5', ['PG', 'SG', 'SF'], 'DEN', 10, 200),
Player('', 'p6', 'p6', ['SF'], 'DEN', 10, 200),
Player('', 'p7', 'p7', ['SF'], 'DEN', 10, 190),
]
self.lineup_optimizer._players.extend(players)
self.lineup_optimizer.add_player_to_lineup(players[0])
self.lineup_optimizer.add_player_to_lineup(players[1])
self.lineup_optimizer.add_player_to_lineup(players[2])
self.lineup_optimizer.add_player_to_lineup(players[3])
lineup = next(self.lineup_optimizer.optimize(1))
self.assertTrue(all([p in lineup.players for p in players[:4]]))
self.lineup_optimizer.add_player_to_lineup(players[4])
lineup = next(self.lineup_optimizer.optimize(1))
self.assertTrue(all([p in lineup.players for p in players[:5]]))
num_of_selected_by_optimizer = len(
list(
filter(lambda p: 'C' in p.positions or 'PF' in p.positions,
lineup.players)))
self.assertEqual(num_of_selected_by_optimizer, 2)
def test_adding_player_to_formed_position(self):
self.lineup_optimizer.reset_lineup()
players = []
for i in 'abcd':
players.append(Player(i, i, i, ['PG'], 'DEN', 10, 2))
for i in range(3):
self.lineup_optimizer.add_player_to_lineup(players[i])
with self.assertRaises(LineupOptimizerException):
self.lineup_optimizer.add_player_to_lineup(players[3])
def setUpClass(cls):
with open('tests/players.json', 'r') as file:
players_dict = json.loads(file.read())['players']
players = [
Player(p['id'], p['first_name'], p['last_name'],
p['positions'], p['team'], p['salary'], p['fppg'])
for p in players_dict
]
cls.players = players
def test_remove_player_from_lineup(self):
optimizer = self.lineup_optimizer
optimizer.reset_lineup()
player = Player(1, 'P', 'P', ['PG'], 'DEN', 10, 2)
optimizer.extend_players([player])
optimizer.add_player_to_lineup(player)
optimizer.remove_player_from_lineup(player)
self.assertNotIn(player, optimizer.locked_players)
with self.assertRaises(LineupOptimizerException):
optimizer.remove_player_from_lineup(player)
