def test_box_score_fails(self, m):
self.mock_setUp(m)
league = League(self.league_id, self.season)
with self.assertRaises(Exception):
league.box_scores(1)
def test_box_scores(self):
league = League(1234, 2018)
box_scores = league.box_scores(5)
self.assertEqual(repr(box_scores[1].away_team), 'Team(Team 5)')
self.assertEqual(repr(box_scores[1].away_lineup[1]), 'Player(Keenan Allen, points:9, projected:10)')
def getScores():
global timesLooped
global finishTime
if timesLooped == 0:
startTime = beginTime
else:
startTime = finishTime
startTime = startTime.replace(microsecond=0)
print("Started at: ", startTime)
boxScore = PrettyTable()
boxScore.field_names = [
"\033[0;30;47m League \033[0;37;40m",
"\033[0;30;47m Home Team \033[0;37;40m",
"\033[0;30;47m H \033[0;37;40m", "\033[0;30;47m vs \033[0;37;40m",
"\033[0;30;47m A \033[0;37;40m",
"\033[0;30;47m Away Team \033[0;37;40m"
]
for x in range(len(leagues)):
league_id = leagues[x]
league = League(league_id, year)
box_score = league.box_scores(currentWeek)
i = 0
for i in range(len(box_score)):
home_team = box_score[i].home_team
away_team = box_score[i].away_team
home_name = home_team.team_name
away_name = away_team.team_name
if home_name == teamNames[x]:
home_score = box_score[i].home_score
away_score = box_score[i].away_score
home_name = "\033[1;32;40m " + home_name + " \033[0;37;40m"
home_score = "\033[1;32;40m " + str(
home_score) + " \033[0;37;40m"
away_score = "\033[1;31;40m " + str(
away_score) + " \033[0;37;40m"
boxScore.add_row([
leagueNames[x], home_name, home_score, "vs", away_score,
away_name
])
if away_name == teamNames[x]:
home_score = box_score[i].home_score
away_score = box_score[i].away_score
away_name = "\033[1;32;40m " + away_name + " \033[0;37;40m"
away_score = "\033[1;32;40m " + str(
away_score) + " \033[0;37;40m"
home_score = "\033[1;31;40m " + str(
home_score) + " \033[0;37;40m"
boxScore.add_row([
leagueNames[x], home_name, home_score, "vs", away_score,
away_name
])
finishTime = datetime.datetime.now()
finishTime = finishTime.replace(microsecond=0)
runtime = finishTime - startTime
#runtime = runtime.replace(microsecond = 0)
timesLooped = timesLooped + 1
print(boxScore)
print("[", timesLooped, "] ", "Updated: ", finishTime, " (runtime: ",
runtime, ")\n")
signal.signal(signal.SIGINT, keyboardInterruptHandler)
def test_box_scores(self):
league = League(48153503, 2019)
box_scores = league.box_scores(week=2)
self.assertEqual(repr(box_scores[1].away_team), 'Team(TEAM BERRY)')
self.assertEqual(repr(box_scores[1].away_lineup[1]),
'Player(Odell Beckham Jr., points:29, projected:16)')
def test_box_score(self, m):
self.mock_setUp(m)
league = League(self.league_id, self.season)
with open('tests/unit/data/league_boxscore_2018.json') as f:
data = json.loads(f.read())
m.get(self.espn_endpoint + '?view=mMatchup&view=mMatchupScore&scoringPeriodId=13', status_code=200, json=data)
box_scores = league.box_scores(13)
self.assertEqual(repr(box_scores[0].home_team), 'Team(Rollin\' With Mahomies)')
self.assertEqual(repr(box_scores[0].home_lineup[1]), 'Player(Christian McCaffrey, points:31, projected:23)')
def findTraitors():
global timesLooped
global finishTime
global myPlayers
global oppPlayers
global allPlayers
print("Started at: ", beginTime)
if timesLooped == 0:
startTime = beginTime
else:
startTime = finishTime
boxScore = PrettyTable()
boxScore.field_names = [
"\033[0;30;47m Player \033[0;37;40m",
"\033[0;30;47m Position \033[0;37;40m",
"\033[0;30;47m For \033[0;37;40m",
"\033[0;30;47m Against \033[0;37;40m"
]
for x in range(len(leagues)):
league_id = leagues[x]
league = League(league_id, year)
box_score = league.box_scores(currentWeek)
i = 0
for i in range(len(box_score)):
home_team = box_score[i].home_team
away_team = box_score[i].away_team
home_name = home_team.team_name
away_name = away_team.team_name
if home_name == teamNames[x]:
home_score = box_score[i].home_score
away_score = box_score[i].away_score
home_lineup = box_score[i].home_lineup
away_lineup = box_score[i].away_lineup
for player in range(len(home_lineup)):
player_name = home_lineup[player].name
player_pos = home_lineup[player].slot_position
myPlayers.append((player_name, player_pos))
allPlayers.append((player_name, player_pos))
for player in range(len(away_lineup)):
player_name = away_lineup[player].name
player_pos = away_lineup[player].slot_position
oppPlayers.append((player_name, player_pos))
allPlayers.append((player_name, player_pos))
if away_name == teamNames[x]:
home_score = box_score[i].home_score
away_score = box_score[i].away_score
home_lineup = box_score[i].home_lineup
away_lineup = box_score[i].away_lineup
for player in range(len(home_lineup)):
player_name = home_lineup[player].name
player_pos = home_lineup[player].slot_position
oppPlayers.append((player_name, player_pos))
allPlayers.append((player_name, player_pos))
for player in range(len(away_lineup)):
player_name = away_lineup[player].name
player_pos = away_lineup[player].slot_position
myPlayers.append((player_name, player_pos))
allPlayers.append((player_name, player_pos))
for z in range(len(allPlayers)):
name = allPlayers[z]
if (name[1] != "BE") and (name[1] != "IR"):
forCount = Counter(myPlayers)[name]
againstCount = Counter(oppPlayers)[name]
fullPlayers.append((name, forCount, againstCount))
finishTime = datetime.datetime.now()
runtime = finishTime - startTime
playerList = list(dict.fromkeys(fullPlayers))
for i in range(len(playerList)):
if (playerList[i][1] > 0) and ((playerList[i][2] > 0)):
displayName = playerList[i][0][0]
displayPos = playerList[i][0][1]
plays = playerList[i][1] + playerList[i][2]
boxScore.add_row(
[displayName, displayPos, playerList[i][1], playerList[i][2]])
boxScore.sortby = "\033[0;30;47m Position \033[0;37;40m"
print(boxScore)
print("Processed at: ", finishTime, "\nRuntime: ", runtime, "")
def test_bad_box_scores(self):
league = League(1234, 2018)
with self.assertRaises(Exception):
league.box_scores()
def get_dudes(my_league):
starting_lineup = []
if my_league['platform'] == 'ESPN':
from ff_espn_api import League
league_id = my_league['league_id']
year = my_league['year']
swid = my_league['swid']
espn_s2 = my_league['espn_s2']
team_num = my_league['team_num']
league = League(league_id, year, espn_s2, swid)
my_team = league.teams[team_num - 1]
my_dudes = my_team.roster
my_pals = [
dude.name for dude in my_dudes
if not ('D/ST' in dude.eligibleSlots or 'K' in dude.eligibleSlots)
]
my_pos = [
dude.position for dude in my_dudes
if not ('D/ST' in dude.eligibleSlots or 'K' in dude.eligibleSlots)
]
my_def = [
dude.proTeam for dude in my_dudes if 'D/ST' in dude.eligibleSlots
]
my_kick = [dude.name for dude in my_dudes if 'K' in dude.eligibleSlots]
teams = league.teams
rosters = [team.roster for team in teams]
rostered_pals = []
rostered_def = []
rostered_kick = []
for roster in rosters:
dudes = [
dude.name for dude in roster if not (
'D/ST' in dude.eligibleSlots or 'K' in dude.eligibleSlots)
]
rostered_pals.extend(dudes)
rostered_def.extend([
dude.proTeam for dude in roster if 'D/ST' in dude.eligibleSlots
])
rostered_kick.extend(
[dude.name for dude in roster if 'K' in dude.eligibleSlots])
team_name = my_team.team_name
boxscores = league.box_scores()
for boxscore in boxscores:
if boxscore.away_team.team_name == team_name:
my_guys = boxscore.away_lineup
elif boxscore.home_team.team_name == team_name:
my_guys = boxscore.home_lineup
for guy in my_guys:
if guy.slot_position not in ['D/ST', 'K', 'BE']:
starting_lineup.append(guy.name)
elif my_league['platform'] == 'YAHOO':
from yahoo_oauth import OAuth2
import yahoo_fantasy_api as yfa
oauth_file = my_league['oauth_file']
lg_number = my_league['lg_number']
sc = OAuth2(None, None, from_file=oauth_file)
gm = yfa.Game(sc, 'nfl')
league = gm.to_league(lg_number)
week = league.current_week()
team_objs = league.teams()
team_keys = [team['team_key'] for team in team_objs]
teams = [league.to_team(key) for key in team_keys]
rosters = [team.roster(week) for team in teams]
rostered_pals = []
rostered_def = []
rostered_kick = []
for roster in rosters:
dudes = [
dude['name'] for dude in roster
if not ('K' in dude['eligible_positions']
or 'DEF' in dude['eligible_positions'])
]
rostered_pals.extend(dudes)
rostered_def.extend([
dude['name'] for dude in roster
if 'DEF' in dude['eligible_positions']
])
rostered_kick.extend([
dude['name'] for dude in roster
if 'K' in dude['eligible_positions']
])
my_team = league.to_team(league.team_key())
my_roster = my_team.roster(week)
my_pals = [
dude['name'] for dude in my_roster
if not ('K' in dude['eligible_positions']
or 'DEF' in dude['eligible_positions'])
]
my_pos = [
dude['eligible_positions'][0] for dude in my_roster
if not ('K' in dude['eligible_positions']
or 'DEF' in dude['eligible_positions'])
]
my_def = [
dude['name'] for dude in my_roster
if 'DEF' in dude['eligible_positions']
]
my_kick = [
dude['name'] for dude in my_roster
if 'K' in dude['eligible_positions']
]
starting_lineup = [
dude['name'] for dude in my_roster
if not dude['selected_position'] in ['BN', 'K', 'DEF']
]
def_map = { #This neglects the RAMS and the GIANTS because Yahoo is dumb and I don't want to figure out their player IDs.
'New England': 'NE',
'Chicago': 'CHI',
'Tampa Bay': 'TB',
'Tennessee': 'TEN',
'San Francisco': 'SF',
'New York': 'NYJ',
'Green Bay': 'GB',
'New Orleans': 'NO',
'Pittsburgh': 'PIT',
'Carolina': 'CAR',
'Detroit': 'DET',
'Seattle': 'SEA',
'Cleveland': 'CLE',
'Los Angeles': 'LAC',
'Kansas City': 'KC',
'Minnesota': 'MIN',
'Buffalo': 'BUF',
'Dallas': 'DAL',
'Houston': 'HOU',
'Jacksonville': 'JAX',
'Indianapolis': 'IND',
'Oakland': 'OAK',
'Washington': 'WAS',
'Baltimore': 'BAL',
'Philadelphia': 'PHI',
'Arizona': 'ARI',
'Atlanta': 'ATL',
'Cincinnati': 'CIN',
'Denver': 'DEN',
'Miami': 'MIA'
}
my_def = [def_map[d] for d in my_def]
rostered_def = [def_map[d] for d in rostered_def]
elif my_league['platform'] == 'SLEEPER':
from sleeper_wrapper import League, Players
import pickle
import os.path
league_id = my_league['league_id']
players_file = my_league['players_file']
team_num = my_league['team_num']
league = League(league_id)
rosters = league.get_rosters()
# Not supposed to call this all the time because it is a large file (5MB)
if os.path.isfile(players_file):
with open(players_file, 'rb') as f:
players = pickle.load(f)
else:
P = Players()
players = P.get_all_players()
with open(players_file, 'wb') as f:
pickle.dump(players, f)
my_team = rosters[team_num - 1]
my_dudes = [players[id] for id in my_team['players']]
my_pals = [
dude['full_name'] for dude in my_dudes
if not (('DEF' in dude['fantasy_positions']) or
('K' in dude['fantasy_positions']))
]
starting_dudes = [players[id] for id in my_team['starters']]
starting_lineup = [
dude['full_name'] for dude in starting_dudes
if not (('DEF' in dude['fantasy_positions']) or
('K' in dude['fantasy_positions']))
]
my_pos = [
dude['position'] for dude in my_dudes
if not (('DEF' in dude['fantasy_positions']) or
('K' in dude['fantasy_positions']))
]
my_def = [
dude['player_id'] for dude in my_dudes
if 'DEF' in dude['fantasy_positions']
]
my_kick = [
dude['full_name'] for dude in my_dudes
if 'K' in dude['fantasy_positions']
]
rostered_teams = [roster['players'] for roster in rosters]
rostered_players = sum(rostered_teams, [])
rostered_dudes = [players[id] for id in rostered_players]
rostered_pals = [
dude['full_name'] for dude in rostered_dudes
if not (('DEF' in dude['fantasy_positions']) or
('K' in dude['fantasy_positions']))
]
rostered_def = [
dude['player_id'] for dude in rostered_dudes
if 'DEF' in dude['fantasy_positions']
]
rostered_kick = [
dude['full_name'] for dude in rostered_dudes
if 'K' in dude['fantasy_positions']
]
else:
raise ValueError('League platform ' + league.platform +
' is not supported.')
return my_pals, my_pos, rostered_pals, my_def, rostered_def, my_kick, rostered_kick, clean_names(
starting_lineup)
if player.name not in players.keys():
players[player.name] = [np.NaN] * (4 * (week - 1) + 4)
players[player.name][0] = np.NaN
players[player.name][3] = player.position
players[player.name].extend([
player.points, player.pro_pos_rank, \
player.projected_points, player.slot_position
])
players[player.name][3] = player.position
# iterating through weeks, matchups, and players to
# append weekly points for each player
for week in range(1, weeks_completed):
for matchup in league.box_scores(week):
for player in matchup.home_lineup:
update_players(player, week)
for player in matchup.away_lineup:
update_players(player, week)
# adding NaN entries for players not in lineups
for player in players.keys():
if len(players[player]) < (week * 4 + 2):
players[player].extend([np.NaN] * 4)
assert len(players[player]) == (week*4+4), \
"Player, {} doesn't match after week {}".format(player, week)
##########################
### Cleaning dataframe ###