def _player_list_to_lineup(self, players):
player_dict = dict()
for (player, slot) in players:
cur_list = player_dict.get(slot, list())
cur_list.append(player)
player_dict[slot] = cur_list
return Lineup(player_dict, self._slot_enum())
def _cumulative_stats(self, lineup: Lineup):
"""
Calculates an approximation of the final statistics of this lineup, assuming
ideal management (setting lineups daily, etc.)
:param Lineup lineup: the lineup to examine and use to calculate stats
:return Stats: the accumulated, year-end total stats
"""
total_stats = Stats({}, BaseballStat)
for p in lineup.starters():
total_stats += self._get_projection(p.name) or Stats({},
BaseballStat)
for p in lineup.benched():
total_stats += self._get_projection(p.name) or Stats(
{}, BaseballStat) * self.likelihood(p, lineup)
return total_stats
def opt(opt_p, budget, desired, remove, n=None):
if n:
squad = Opt.transfer_simulation(opt_p, processed_data, n, budget,
desired, remove)
else:
squad = Opt.wildcard_simulation(opt_p, processed_data, budget, desired,
remove)
if squad.prob.status == 1:
player, subs = squad.extract_subs()
old, new = squad.calculate_improvement()
print('\n\nSubstitution simulation complete (', opt_p, '),', sep='')
print('previous ',
opt_p,
' - ',
round(old, 1),
'\n',
'new ',
opt_p,
' - ',
round(new, 1),
sep='')
print('That\'s an improvement of -', round(new - old, 1))
print('\nOptimal subs:')
for p, s in zip(player, subs):
print(p['web_name'], '>', s['web_name'])
print('\nBest team/formation is as follows:')
Lineup(squad.squad, param=opt_p).print_lineup()
else:
print(
'Unable to find solution with specified parameters. Simulation status code:',
squad.prob.status)
class Test(unittest.TestCase):
rizzo = Player("Anthony Rizzo", None, None, 123, {BaseballSlot.FIRST},
None)
goldschmidt = Player("Paul Goldschmidt", None, None, 456,
{BaseballSlot.FIRST}, None)
empty_lineup = Lineup(dict(), BaseballSlot)
basic_node = LineupSearchNode(empty_lineup, [rizzo], {BaseballSlot.FIRST})
simple_settings = LineupSettings({BaseballSlot.FIRST: 1})
two_firsts_left_node = LineupSearchNode(empty_lineup, [rizzo, goldschmidt],
{BaseballSlot.FIRST})
def test_successors_one_player(self):
result = self.basic_node.successors(self.simple_settings)
self.assertEqual(len(result), 1)
successor = result[0]
self.assertEqual(len(successor.players_left), 0)
self.assertEqual(successor.lineup.starters(), {self.rizzo})
def test_successors_two_players(self):
result = self.two_firsts_left_node.successors(self.simple_settings)
self.assertEqual(len(result), 2)
s0 = result[0]
s0rem = s0.players_left[0]
s0first = s0.lineup.player_dict.get(BaseballSlot.FIRST)[0]
s1 = result[1]
s1rem = s1.players_left[0]
s1first = s1.lineup.player_dict.get(BaseballSlot.FIRST)[0]
self.assertEqual({s0rem, s1rem}, {self.rizzo, self.goldschmidt})
self.assertNotEqual(s0rem, s0first)
self.assertNotEqual(s1rem, s1first)
self.assertEqual(s0rem, s1first)
def player_list_to_lineup(players):
player_dict = dict()
for (player, slot) in players:
cur_list = player_dict.get(slot, list())
cur_list.append(player)
player_dict[slot] = cur_list
return Lineup(player_dict)
def test_transitions_single_swap(self):
carpenter_first_dict = self.empty_lineup_dict.copy()
carpenter_first_dict[BaseballSlot.FIRST] = [PlayerTest.carpenter]
cf_lineup = Lineup(carpenter_first_dict, BaseballSlot)
carpenter_corner_inf_dict = self.empty_lineup_dict.copy()
carpenter_corner_inf_dict[BaseballSlot.CORNER_INFIELD] = [
PlayerTest.carpenter
]
cci_lineup = Lineup(carpenter_corner_inf_dict, BaseballSlot)
transitions = cf_lineup.transitions(cci_lineup)
self.assertEqual(len(transitions), 1)
self.assertTrue(
LineupTransition(PlayerTest.carpenter, BaseballSlot.FIRST,
BaseballSlot.CORNER_INFIELD) in transitions)
def test_transitions_swap_two_players(self):
l1_dict = self.empty_lineup_dict.copy()
l1_dict[BaseballSlot.BENCH] = [PlayerTest.merrifield]
l1_dict[BaseballSlot.OUTFIELD] = [PlayerTest.yelich]
l1 = Lineup(l1_dict, BaseballSlot)
l2_dict = self.empty_lineup_dict.copy()
l2_dict[BaseballSlot.OUTFIELD] = [PlayerTest.merrifield]
l2_dict[BaseballSlot.BENCH] = [PlayerTest.yelich]
l2 = Lineup(l2_dict, BaseballSlot)
transitions = l1.transitions(l2)
self.assertEqual(len(transitions), 2)
self.assertTrue(
LineupTransition(PlayerTest.merrifield, BaseballSlot.BENCH,
BaseballSlot.OUTFIELD) in transitions)
self.assertTrue(
LineupTransition(PlayerTest.yelich, BaseballSlot.OUTFIELD,
BaseballSlot.BENCH) in transitions)
def optimize(self, n=1):
logging.debug('start optimizer n = {}'.format(n))
self.recursion_counter = 0
lu = Lineup(site_name=constants.dk)
pool = self.pool
logging.debug('Pool /n' + repr(pool))
opt = self.__recursive_step(pool, lu)
return opt
def from_dict(cls, dct): # type: (dict) -> Headend
"""
:param dct:
:return:
"""
headend = cls()
headend.headend_id = dct.pop("headend")
headend.type = dct.pop("transport")
headend.location = dct.pop("location")
headend.lineups = Lineup.from_iterable(dct.pop("lineups"))
if len(dct) != 0:
logging.warn("Key(s) not processed for Headend: %s", ", ".join(dct.keys()))
return headend
def from_dict(cls, dct): # type: (dict) -> LineupMap
"""
:param dct:
:return:
"""
lineup_map = cls()
lineup_map.stations = Station.from_iterable(dct.pop("stations"))
lineup_map.channels = Channel.from_iterable(dct.pop("map"))
for channel in lineup_map.channels:
channel.station = lineup_map.get_station(channel.station_id)
lineup_map.lineup = Lineup.from_dict(dct.pop("metadata"))
if len(dct) != 0:
logging.warn("Key(s) not processed for LineupMap: %s", ", ".join(dct.keys()))
return lineup_map
def from_dict(cls, dct): # type: (dict) -> Status
"""
:param dct:
:return:
"""
status = cls()
if "account" in dct:
status.account = StatusAccount.from_dict(dct.pop("account"))
if "lineups" in dct:
status.lineups = Lineup.from_iterable(dct.pop("lineups"))
if "lastDataUpdate" in dct:
status.last_data_update = parse_datetime(dct.pop("lastDataUpdate"))
if "notifications" in dct:
status.notifications = dct.pop("notifications")
if "systemStatus" in dct:
if len(dct["systemStatus"]) != 0:
status.system_status = StatusSystem.from_dict(
dct.pop("systemStatus")[0])
if "serverID" in dct:
status.server_id = dct.pop("serverID")
if "code" in dct:
status.code = dct.pop("code")
if "datetime" in dct:
status.datetime = parse_datetime(dct.pop("datetime"))
if len(dct) != 0:
logging.warn("Key(s) not processed for Status: %s",
", ".join(dct.keys()))
return status
def from_dict(cls, dct): # type: (dict) -> LineupMap
"""
:param dct:
:return:
"""
lineup_map = cls()
lineup_map.stations = Station.from_iterable(dct.pop("stations"))
lineup_map.channels = Channel.from_iterable(dct.pop("map"))
for channel in lineup_map.channels:
channel.station = lineup_map.get_station(channel.station_id)
lineup_map.lineup = Lineup.from_dict(dct.pop("metadata"))
if len(dct) != 0:
logging.warn("Key(s) not processed for LineupMap: %s",
", ".join(dct.keys()))
return lineup_map
def from_dict(cls, dct): # type: (dict) -> Status
"""
:param dct:
:return:
"""
status = cls()
if "account" in dct:
status.account = StatusAccount.from_dict(dct.pop("account"))
if "lineups" in dct:
status.lineups = Lineup.from_iterable(dct.pop("lineups"))
if "lastDataUpdate" in dct:
status.last_data_update = parse_datetime(dct.pop("lastDataUpdate"))
if "notifications" in dct:
status.notifications = dct.pop("notifications")
if "systemStatus" in dct:
if len(dct["systemStatus"]) != 0:
status.system_status = StatusSystem.from_dict(dct.pop("systemStatus")[0])
if "serverID" in dct:
status.server_id = dct.pop("serverID")
if "code" in dct:
status.code = dct.pop("code")
if "datetime" in dct:
status.datetime = parse_datetime(dct.pop("datetime"))
if len(dct) != 0:
logging.warn("Key(s) not processed for Status: %s", ", ".join(dct.keys()))
return status
import constants
from dfs_site import DFS_Site
from lineup import Lineup
from player import Player
from pool import Pool
from optimizer import Dynamic_Optimizer
import unittest
import pandas as pd
import copy
small_projections = Pool('./small_projections.csv')
empty_lineup = Lineup()
optimizer1 = Dynamic_Optimizer(pool='./small_projections.csv')
optimizer2 = Dynamic_Optimizer(pool='./projections.csv')
test_stat_projections = {
constants.pts: 10,
constants.rbs: 1,
constants.asts: 1,
constants.stls: 1,
constants.blks: 1,
constants.tos: 1,
constants.threes: 1,
constants.dd: 0,
constants.td: 0
}
def starting_lineups(self):
complete = False
away_lineup = Lineup()
home_lineup = Lineup()
away_roster = PlayerList()
home_roster = PlayerList()
away_player_list = [p for p in self._away_html_player_list]
home_player_list = [p for p in self._home_html_player_list]
for player_list, roster, starting_lineup in ((away_player_list,
away_roster,
away_lineup),
(home_player_list,
home_roster,
home_lineup)):
for p in player_list:
if p.starter:
starting_lineup.update_player(p)
roster.update_player(p)
for lineup, which_lineup in [(home_lineup, "Home"),
(away_lineup, "Away")]:
try:
if not lineup.is_complete(raise_reason=False):
options = lineup.find_complete_positions()
if len(options) == 1:
for player, position in zip(lineup, options[0]):
if player.position != position:
d = {
"name": player.name,
"to_p": position,
"from_p": player.position
}
logger.warning(
"Automatically Moving {name} to position {to_p} from position {from_p}"
.format(**d))
player.position = position
elif len(options) > 1:
s = "\n".join([
p.name + " " + str(p.all_positions) for p in lineup
])
logger.critical(
"Too many potential lineups to find the starting lineup \n"
+ s)
self.critical_errors = True
else:
s = "\n".join([
p.name + " " + str(p.all_positions) for p in lineup
])
logger.critical(
"Can not determine complete fielding lineup from \n"
+ s)
self.critical_errors = True
if not lineup.is_complete(
raise_reason=False) and not self.critical_errors:
s = "\n".join(
[p.name + " " + str(p.all_positions) for p in lineup])
logger.critical("lineup not complete \n" + s)
self.critical_errors = True
except LineupError, e:
logging.error(
str(e) + "\n" + which_lineup + "\n" + str(lineup))
def home_lineup(self):
lineup = Lineup()
for p in self._home_roster_share:
if p.starter:
lineup.append(p)
return lineup
def calculate_lineups(db, date_for_lineup, number_of_lineups, lineup_type="initial"):
# Create lineups/entries for all combinations of top goalies (or chosen goalies) and top value/cost players
# Write top lineups/entries to file
if lineup_type == "initial":
filename = "../resources/lineups/DKLineup_" + date_for_lineup.strftime("%Y%m%d-%H%M%S") + ".csv"
header_row = ["C", "C", "W", "W", "W", "D", "D", "G", "UTIL"]
elif lineup_type == "entry":
filename = "../resources/lineups/DKEntries_" + date_for_lineup.strftime("%Y%m%d-%H%M%S") + ".csv"
header_row = ["Entry ID", "Contest Name", "Contest ID", "Entry Fee", "C", "C", "W", "W", "W", "D", "D", "G",
"UTIL"]
else:
raise ValueError("Invalid entry for lineup_type.")
with open(filename, "w") as csvfile:
writer = csv.writer(csvfile, lineterminator='\n')
writer.writerow(header_row)
logging.debug("Starting creating lineups....")
all_lineups = []
logging.debug("Setting up players with ID and values....")
players = get_player_data(db, date_for_lineup)
if lineup_type == "entry":
entries = get_entries(db, date_for_lineup)
else:
entries = None
logging.debug("Finding starting goalies....")
starting_goalies = get_starting_goalies(db, date_for_lineup)
goalies = [item for item in players if item.get_name() in starting_goalies]
logging.debug(goalies)
if len(goalies) == 0:
raise ValueError("Could not find any starting goalies.")
# Sort list of players and remove any goalies and players with value less than 1.0 and weight 25 or under, or if not active
# Choose one Util from the from of the list
logging.debug("Finding skaters....")
skaters = copy.deepcopy(players)
active_players = get_all_active_player_ids(db)
skaters = [item for item in skaters if
item.get_position() != "G" and
item.get_value() > 1.0 and
item.get_weight() > 25 and
item.get_player_id() != None and
item.get_player_id() in active_players]
# for skater in skaters:
# logging.info(skater)
# logging.info(skater.get_player_id())
limit = 500
# for i in range(len(chosen_goalies)):
# skaters = copy.deepcopy(players)
# Use the following statements to check a specific player's value
# ss_value = [item for item in skaters if item['nameAndId'] == 'Steven Stamkos (7723976)'][0]['value']
# logging.debug("Steven Stamkos value: " + str(ss_value) + ", players length: " + str(len(players)))
for i in range(number_of_lineups):
# Find the chosen goalies
# chosen_goalie = [item for item in players if item.get_name_and_id() == chosen_goalies[i]][0]
# Add random noise in order to get varied results
# unused_players_with_noise = unused_players
for skater in skaters:
skater.add_value(random.uniform(-0.25, 0.25))
# Choose a Util based on the best value
skaters = sorted(skaters, key=lambda tup: tup.get_value(), reverse=True)
chosen_util = skaters[0]
# Remove Util from skaters (will be returned after calculating the set)
skaters = [item for item in skaters if item.get_name_and_id() != chosen_util.get_name_and_id()]
# skaters = [item for item in unused_players if item['position'] != "G"]
logging.info("Getting lineup with " + chosen_util.get_name_and_id() + " as Util.")
calculated_set_of_players = calculate_sets_of_players(skaters, goalies, chosen_util, limit)
calculated_set_of_players = sorted(calculated_set_of_players, key=lambda tup: tup[10], reverse=True)
calculated_lineup = Lineup(db, calculated_set_of_players[0])
logging.debug(calculated_lineup)
# Add Util back in for next loop
skaters.append(chosen_util)
# Lower value of non-chosen players in selected set (C,W,D), as they've already been selected
for skater in skaters:
if skater.get_name_and_id() in calculated_set_of_players[0]:
logging.info("Lowering value of " + str(skater.get_name_and_id()) + " by 0.25.")
skater.add_value(-0.25)
for goalie in goalies:
if goalie.get_name_and_id() in calculated_set_of_players[0]:
logging.info("Lowering value of " + str(goalie.get_name_and_id()) + " by 0.25.")
goalie.add_value(-0.25)
# Write top lineup to csv
writer.writerow(calculated_set_of_players[0][:9])
csvfile.flush()
# Add found lineup to all lineups
logging.info(calculated_lineup)
all_lineups.append(calculated_lineup)
# Remove goalie from players
# players = [item for item in players if item.get_name_and_id() != chosen_goalie.get_name_and_id()]
csvfile.close()
# Sort final lineups, add to entries, and print
all_lineups = sorted(all_lineups, key=lambda tup: tup.get_total_value(), reverse=True)
for s in range(len(all_lineups)):
if lineup_type == "entry":
entries[s].set_lineup(all_lineups[s])
logging.info(entries[s].get_list())
else:
logging.info(all_lineups[s].get_list())
# Write all lineups to database
for lineup in all_lineups:
lineup.insert_lineup()
with open("../resources/lineups/DKAllLineups_" + date_for_lineup.strftime("%Y%m%d-%H%M%S") + ".csv",
"w") as csvfile:
writer = csv.writer(csvfile, lineterminator='\n')
writer.writerow(["C", "C", "W", "W", "W", "D", "D", "G", "UTIL", "Weight", "Value"])
for s in range(len(all_lineups)):
writer.writerow(all_lineups[s].get_list())
csvfile.close()
if lineup_type == "entry":
with open("../resources/lineups/DKEntries_" + date_for_lineup.strftime("%Y%m%d-%H%M%S") + ".csv",
"w") as csvfile:
writer = csv.writer(csvfile, lineterminator='\n')
writer.writerow(
["Entry ID", "Contest Name", "Contest ID", "Entry Fee", "C", "C", "W", "W", "W", "D", "D", "G",
"UTIL"]) # , "Weight", "Value"])
for s in range(len(entries)):
writer.writerow(entries[s].get_list()[:13])
csvfile.close()
class LineupTest(unittest.TestCase):
empty_lineup_dict = {
BaseballSlot.CATCHER: [],
BaseballSlot.FIRST: [],
BaseballSlot.SECOND: [],
BaseballSlot.THIRD: [],
BaseballSlot.SHORT: [],
BaseballSlot.OUTFIELD: [],
BaseballSlot.MIDDLE_INFIELD: [],
BaseballSlot.CORNER_INFIELD: [],
BaseballSlot.UTIL: [],
BaseballSlot.PITCHER: [],
BaseballSlot.BENCH: [],
BaseballSlot.INJURED: [],
}
base_lineup_dict = {
BaseballSlot.CATCHER: [PlayerTest.sanchez],
BaseballSlot.FIRST: [PlayerTest.muncy],
BaseballSlot.SECOND: [PlayerTest.merrifield],
BaseballSlot.THIRD: [PlayerTest.carpenter],
BaseballSlot.SHORT: [PlayerTest.segura],
BaseballSlot.OUTFIELD: [
PlayerTest.springer,
PlayerTest.rosario,
PlayerTest.braun,
PlayerTest.santana,
PlayerTest.choo,
],
BaseballSlot.MIDDLE_INFIELD: [PlayerTest.cano],
BaseballSlot.CORNER_INFIELD: [PlayerTest.rizzo],
BaseballSlot.UTIL: [PlayerTest.cabrera],
BaseballSlot.PITCHER: [
PlayerTest.degrom,
PlayerTest.kimbrel,
PlayerTest.morton,
PlayerTest.hill,
PlayerTest.arrieta,
PlayerTest.glasnow,
PlayerTest.barnes,
PlayerTest.stripling,
PlayerTest.smith,
],
BaseballSlot.BENCH:
[PlayerTest.paddack, PlayerTest.yelich, PlayerTest.peraza],
BaseballSlot.INJURED: [PlayerTest.olson, PlayerTest.jimenez],
}
simple_lineup = Lineup(base_lineup_dict, BaseballSlot)
def test_possible_starters_one_slot(self):
lineup_settings = LineupSettings({
BaseballSlot.CATCHER: 0,
BaseballSlot.FIRST: 1,
BaseballSlot.SECOND: 0,
BaseballSlot.THIRD: 0,
BaseballSlot.SHORT: 0,
BaseballSlot.MIDDLE_INFIELD: 0,
BaseballSlot.CORNER_INFIELD: 0,
BaseballSlot.OUTFIELD: 0,
BaseballSlot.UTIL: 0,
BaseballSlot.BENCH: 0,
BaseballSlot.PITCHER: 0,
BaseballSlot.INJURED: 0,
})
lineups = self.simple_lineup.possible_lineups(
lineup_settings, BaseballSlot.hitting_slots())
starters = set(map(Lineup.starters, lineups))
self.assertEqual(len(starters), 4)
self.assertTrue(frozenset({PlayerTest.rizzo}) in starters)
self.assertTrue(frozenset({PlayerTest.muncy}) in starters)
self.assertTrue(frozenset({PlayerTest.carpenter}) in starters)
self.assertTrue(frozenset({PlayerTest.cabrera}) in starters)
def test_possible_starters_two_slots_no_dups(self):
lineup_settings = LineupSettings({
BaseballSlot.CATCHER: 0,
BaseballSlot.FIRST: 1,
BaseballSlot.SECOND: 0,
BaseballSlot.THIRD: 0,
BaseballSlot.SHORT: 0,
BaseballSlot.MIDDLE_INFIELD: 0,
BaseballSlot.CORNER_INFIELD: 1,
BaseballSlot.OUTFIELD: 0,
BaseballSlot.UTIL: 0,
BaseballSlot.BENCH: 0,
BaseballSlot.PITCHER: 0,
BaseballSlot.INJURED: 0,
})
lineups = self.simple_lineup.possible_lineups(
lineup_settings, BaseballSlot.hitting_slots())
starters = set(map(Lineup.starters, lineups))
self.assertEqual(len(starters), 6)
self.assertTrue(
frozenset({PlayerTest.rizzo, PlayerTest.muncy}) in starters)
self.assertTrue(
frozenset({PlayerTest.rizzo, PlayerTest.carpenter}) in starters)
self.assertTrue(
frozenset({PlayerTest.rizzo, PlayerTest.cabrera}) in starters)
self.assertTrue(
frozenset({PlayerTest.carpenter, PlayerTest.muncy}) in starters)
self.assertTrue(
frozenset({PlayerTest.carpenter, PlayerTest.cabrera}) in starters)
self.assertTrue(
frozenset({PlayerTest.muncy, PlayerTest.cabrera}) in starters)
def test_transitions_single_swap(self):
carpenter_first_dict = self.empty_lineup_dict.copy()
carpenter_first_dict[BaseballSlot.FIRST] = [PlayerTest.carpenter]
cf_lineup = Lineup(carpenter_first_dict, BaseballSlot)
carpenter_corner_inf_dict = self.empty_lineup_dict.copy()
carpenter_corner_inf_dict[BaseballSlot.CORNER_INFIELD] = [
PlayerTest.carpenter
]
cci_lineup = Lineup(carpenter_corner_inf_dict, BaseballSlot)
transitions = cf_lineup.transitions(cci_lineup)
self.assertEqual(len(transitions), 1)
self.assertTrue(
LineupTransition(PlayerTest.carpenter, BaseballSlot.FIRST,
BaseballSlot.CORNER_INFIELD) in transitions)
def test_transitions_swap_two_players(self):
l1_dict = self.empty_lineup_dict.copy()
l1_dict[BaseballSlot.BENCH] = [PlayerTest.merrifield]
l1_dict[BaseballSlot.OUTFIELD] = [PlayerTest.yelich]
l1 = Lineup(l1_dict, BaseballSlot)
l2_dict = self.empty_lineup_dict.copy()
l2_dict[BaseballSlot.OUTFIELD] = [PlayerTest.merrifield]
l2_dict[BaseballSlot.BENCH] = [PlayerTest.yelich]
l2 = Lineup(l2_dict, BaseballSlot)
transitions = l1.transitions(l2)
self.assertEqual(len(transitions), 2)
self.assertTrue(
LineupTransition(PlayerTest.merrifield, BaseballSlot.BENCH,
BaseballSlot.OUTFIELD) in transitions)
self.assertTrue(
LineupTransition(PlayerTest.yelich, BaseballSlot.OUTFIELD,
BaseballSlot.BENCH) in transitions)
class TestDraftState(TestCase):
ls = LineupSettings({
BaseballSlot.OUTFIELD: 2,
BaseballSlot.SHORT: 1,
BaseballSlot.PITCHER: 1,
BaseballSlot.UTIL: 1,
BaseballSlot.BENCH: 1,
})
l1 = Lineup(
{
BaseballSlot.OUTFIELD: [PlayerTest.yelich, PlayerTest.braun],
BaseballSlot.UTIL: [PlayerTest.santana],
},
BaseballSlot,
)
l2 = Lineup(
{
BaseballSlot.PITCHER: [PlayerTest.degrom],
BaseballSlot.SHORT: [PlayerTest.segura],
},
BaseballSlot,
)
l3 = Lineup(
{BaseballSlot.OUTFIELD: [PlayerTest.springer, PlayerTest.rosario]},
BaseballSlot)
info = DraftGameInfo(3, 100, ls)
state = DraftState(
info,
{
PlayerTest.springer,
PlayerTest.rosario,
PlayerTest.degrom,
PlayerTest.segura,
PlayerTest.rizzo,
PlayerTest.peraza,
PlayerTest.choo,
PlayerTest.morton,
PlayerTest.yelich,
PlayerTest.braun,
PlayerTest.santana,
},
{
PlayerTest.springer,
PlayerTest.rosario,
PlayerTest.degrom,
PlayerTest.segura,
PlayerTest.yelich,
PlayerTest.braun,
PlayerTest.santana,
},
[l1, l2, l3],
0,
True,
)
small_lineup_settings = LineupSettings({
BaseballSlot.OUTFIELD: 1,
BaseballSlot.INJURED: 1
})
sl0 = Lineup({BaseballSlot.OUTFIELD: [PlayerTest.springer]}, BaseballSlot)
sl1 = Lineup({BaseballSlot.OUTFIELD: [PlayerTest.rosario]}, BaseballSlot)
sl2 = Lineup({BaseballSlot.OUTFIELD: [PlayerTest.yelich]}, BaseballSlot)
terminal_state = DraftState(
DraftGameInfo(3, 1000, small_lineup_settings),
{PlayerTest.springer, PlayerTest.rosario, PlayerTest.yelich},
{PlayerTest.springer, PlayerTest.rosario, PlayerTest.yelich},
[sl0, sl1, sl2],
0,
True,
)
def test__possible_additions(self):
poss_p0 = self.state._possible_additions(0)
self.assertEqual(4, len(poss_p0))
self.assertTrue((PlayerTest.rizzo, BaseballSlot.BENCH) in poss_p0)
self.assertTrue((PlayerTest.peraza, BaseballSlot.SHORT) in poss_p0)
self.assertTrue((PlayerTest.choo, BaseballSlot.BENCH) in poss_p0)
self.assertTrue((PlayerTest.morton, BaseballSlot.PITCHER) in poss_p0)
poss_p1 = self.state._possible_additions(1)
self.assertEqual(4, len(poss_p1))
self.assertTrue((PlayerTest.rizzo, BaseballSlot.UTIL) in poss_p1)
self.assertTrue((PlayerTest.peraza, BaseballSlot.UTIL) in poss_p1)
self.assertTrue((PlayerTest.choo, BaseballSlot.OUTFIELD) in poss_p1)
self.assertTrue((PlayerTest.morton, BaseballSlot.BENCH) in poss_p1)
poss_p2 = self.state._possible_additions(2)
self.assertEqual(4, len(poss_p2))
self.assertTrue((PlayerTest.rizzo, BaseballSlot.UTIL) in poss_p2)
self.assertTrue((PlayerTest.peraza, BaseballSlot.SHORT) in poss_p2)
self.assertTrue((PlayerTest.choo, BaseballSlot.UTIL) in poss_p2)
self.assertTrue((PlayerTest.morton, BaseballSlot.PITCHER) in poss_p2)
def test_children(self):
children_p0 = self.state.children()
self.assertEqual(4, len(children_p0))
for child in children_p0:
# different lineup lists
self.assertTrue(self.state.lineups != child.lineups)
# different lineups for player 0
self.assertNotEqual(self.state.lineups[0], child.lineups[0])
# same lineups for all other players
self.assertEqual(self.state.lineups[1], child.lineups[1])
self.assertEqual(self.state.lineups[2], child.lineups[2])
def test_is_terminal(self):
self.assertFalse(self.state.is_terminal())
self.assertTrue(self.terminal_state.is_terminal())
def test__next_player(self):
self.assertEqual(1, self.state._next_player())
def test__next_player_end_returning(self):
ds = DraftState(self.info, [], {}, [], 2, False)
self.assertEqual(1, ds._next_player())
def test__next_direction(self):
self.assertTrue(self.state._next_direction())
def test__next_direction_returning(self):
ds = DraftState(self.info, [], {}, [], 2, False)
self.assertFalse(ds._next_direction())
def home_lineup(self):
lineup = Lineup()
for p in self._home_roster_share:
if p.starter:
lineup.append(p)
return lineup