def create_game_logs_file(team_id):
"""Creates file for each NBA team containing game info from last season
:param team_id: ID number of the team
"""
# team game log
path = os.path.join(TEAM_BASE_PATH, TEAM_DICT[team_id] + '.json')
if not os.path.exists(path):
print("Retrieving team " + TEAM_DICT[team_id] +
" game log, season stats ... Please wait.")
game_logs = team.TeamGameLogs(team_id, '2016-17').json
with open(path, 'w') as outfile:
json.dump(game_logs, outfile)
# playoff game log
playoff_path = os.path.join(TEAM_PLAYOFF_PATH,
TEAM_DICT[team_id] + '.json')
if not os.path.exists(playoff_path):
playoff_games = team.TeamGameLogs(team_id, '2016-17',
constants.SeasonType.Playoffs).json
if len(playoff_games['resultSets'][0]['rowSet']):
with open(playoff_path, 'w') as playoff_files:
json.dump(playoff_games, playoff_files)
# season stats
season_path = os.path.join(TEAM_SEASON_PATH, TEAM_DICT[team_id] + '.json')
if not os.path.exists(season_path):
season_stats = team.TeamSeasons(team_id).json
with open(season_path, 'w') as season_files:
json.dump(season_stats, season_files)
def get_team_game_log(self) -> Dict[str, pd.DataFrame]:
"""Retrieve individual team game log data using API.
"""
regular = pd.DataFrame()
post = pd.DataFrame()
for _team in self.team_list.itertuples(index=False):
self.logger.info(f'Retrieving team game log data for {_team.TEAM_ID}')
data = team.TeamGameLogs(_team.TEAM_ID, season=self.season).info()
regular = regular.append(data, ignore_index=True)
data = team.TeamGameLogs(_team.TEAM_ID, season_type=SeasonType.Playoffs, season=self.season).info()
post = post.append(data, ignore_index=True)
time.sleep(0.5)
return {'Regular': regular, 'Post': post}
def test():
team_id = TEAMS['ATL']['id']
player_id = get_player('Lebron', 'James')
assert team.TeamList()
assert team.TeamSummary(team_id)
team_details = team.TeamDetails(team_id)
assert team_details
assert team_details.background()
assert team_details.history()
assert team.TeamCommonRoster(team_id)
assert team.TeamGeneralSplits(team_id)
assert team.TeamOpponentSplits(team_id)
assert team.TeamLastNGamesSplits(team_id)
assert team.TeamInGameSplits(team_id)
assert team.TeamClutchSplits(team_id)
assert team.TeamShootingSplits(team_id)
assert team.TeamPerformanceSplits(team_id)
assert team.TeamLineups(team_id)
assert team.TeamPlayers(team_id)
assert team.TeamPlayerOnOffDetail(team_id)
assert team.TeamPlayerOnOffSummary(team_id)
assert team.TeamGameLogs(team_id)
assert team.TeamShotTracking(team_id)
assert team.TeamReboundTracking(team_id)
assert team.TeamPassTracking(team_id)
assert team.TeamVsPlayer(team_id, player_id)
def get_gameDataWithPlayersAndPoints(teamName, season):
team_id = TEAMS[teamName]['id']
df = team.TeamGameLogs(team_id, season).info()
print(df[:5])
# For each game get the players who played and the points and add them to the dataframe line
for g in df["Game_ID"]:
print(g)
player_stats = game.BoxscoreAdvanced(g).sql_players_advanced()
print("columns:::", list(player_stats))
print(player_stats)
players = player_stats["PLAYER_NAME"].values
minutes = player_stats["MIN"].values
#points = player_stats["PTS"].values
teamStartIndices = np.where(
player_stats["START_POSITION"].values == 'F')[0]
home_team_players = players[:teamStartIndices[2]]
away_team_players = players[:teamStartIndices[2]]
# Remove players who didn't play
notPlayingPlayers = np.where(player_stats["MIN"].isnull())[0]
players = np.delete(players, notPlayingPlayers)
#points = np.delete(points, notPlayingPlayers)
#player_stats["PLAYER_NAME"] = players
#df = df.assign(player_stats=pd.Series(player_stats).values)
print("------")
break
return df
def custom_boxscore(roster_id):
game_logs = team.TeamGameLogs(roster_id)
df_game_logs = game_logs.info()
df_game_logs['GAME_DATE'] = pd.to_datetime(df_game_logs['GAME_DATE'])
df_game_logs['DAYS_REST'] = df_game_logs['GAME_DATE'] - df_game_logs[
'GAME_DATE'].shift(-1)
df_game_logs['DAYS_REST'] = df_game_logs['DAYS_REST'].astype(
'timedelta64[D]')
df_all = pd.DataFrame() ##blank dataframe
dates = df_game_logs['GAME_DATE']
for date in dates:
game_info = team.TeamPassTracking(roster_id,
date_from=date,
date_to=date).passes_made()
game_info[
'GAME_DATE'] = date ## We need to append the date to this so we can join back
temp_df = game_info.groupby(['GAME_DATE']).sum()
temp_df.reset_index(level=0, inplace=True)
##now to get the shot info. For the most part, we're just reusing code we've already written
open_info = team.TeamShotTracking(
roster_id, date_from=date,
date_to=date).closest_defender_shooting()
open_info['OPEN'] = open_info['CLOSE_DEF_DIST_RANGE'].map(
lambda x: True if 'Open' in x else False)
temp_df['OPEN_SHOTS'] = open_info.loc[open_info['OPEN'] == True,
'FGA'].sum()
temp_df['OPEN_EFG'] = (
open_info.loc[open_info['OPEN'] == True, 'FGM'].sum() +
(.5 * open_info.loc[open_info['OPEN'] == True, 'FG3M'].sum())) / (
open_info.loc[open_info['OPEN'] == True, 'FGA'].sum())
temp_df['COVERED_EFG'] = (
open_info.loc[open_info['OPEN'] == False, 'FGM'].sum() +
(.5 * open_info.loc[open_info['OPEN'] == False, 'FG3M'].sum())) / (
open_info.loc[open_info['OPEN'] == False, 'FGA'].sum())
##append this to our bigger dataframe
df_all = df_all.append(temp_df)
df_boxscore = pd.merge(df_game_logs,
df_all[[
'PASS', 'FG2M', 'FG2_PCT', 'OPEN_SHOTS',
'OPEN_EFG', 'COVERED_EFG'
]],
how='left',
left_on=df_game_logs['GAME_DATE'],
right_on=df_all['GAME_DATE'])
df_boxscore['PASS_AST'] = df_boxscore['PASS'] / df_boxscore['AST']
df_boxscore['RESULT'] = df_boxscore['WL'].map(lambda x: 1
if 'W' in x else 0)
return df_boxscore
def teams(teamid):
"""Specific team pages.
"""
team_summary = team.TeamSummary(teamid)
team_summary_info = team_summary.info()
team_season_ranks = team_summary.season_ranks()
team_common_roster = team.TeamCommonRoster(teamid)
roster = team_common_roster.roster()
coaches = team_common_roster.coaches()
season = team_summary_info[0]["SEASON_YEAR"]
team_game_log = team.TeamGameLogs(teamid, season=season)
team_games = team_game_log.info()
playoffs_teamgamelogs = team.TeamGameLogs(teamid,
season=season,
season_type="Playoffs")
playoffs_team_games = playoffs_teamgamelogs.info()
team_season = team.TeamSeasons(teamid)
team_season_info = team_season.info()
for i in team_season_info:
if (i["YEAR"] == season):
current_season_info = i
return render_template("teams.html",
title=team_summary_info[0]["TEAM_CITY"] + " " +
team_summary_info[0]["TEAM_NAME"],
teamid=teamid,
team_summary_info=team_summary_info,
team_season_ranks=team_season_ranks,
season=season,
team_games=team_games,
playoffs_team_games=playoffs_team_games,
team_season=team_season_info,
roster=roster,
coaches=coaches,
current_season_info=current_season_info,
team_img=TEAM_ID_DATA)
def get_team_game_logs(team_id, season='2016-17'):
try:
team_info = pd.read_pickle('team_game_logs/' + str(team_id) + '-' +
season + '.pckl')
except FileNotFoundError:
print('File not found')
team_info = team.TeamGameLogs(team_id, season=season)
team_info = team_info.info()
team_info.to_pickle('team_game_logs/' + str(team_id) + '-' + season +
'.pckl')
return team_info
def load_team_game_data_at_year(teamName, year):
teamId = TEAMS[teamName]['id']
season = get_season(year)
header = ['Team_ID', 'Game_ID', 'GAME_DATE', 'MATCHUP', 'WL', 'MIN', 'FGM',
'FGA', 'FG_PCT', 'FG3M',
'FG3A', 'FG3_PCT', 'FTM', 'FTA', 'FT_PCT',
'OREB', 'DREB', 'REB', 'AST', 'STL', 'BLK', 'TOV', 'PF', 'PTS']
gameData = team.TeamGameLogs(teamId, season).info()
gameData = gameData[header]
gameData['Season'] = season
return gameData
def teams_and_season(teamid, season):
# season example: "2016-17"
# type example: "Regular Season" or "Playoffs"
team_game_log = team.TeamGameLogs(teamid, season=season)
team_games = team_game_log.info()
playoffs_teamgamelogs = team.TeamGameLogs(teamid,
season=season,
season_type="Playoffs")
playoffs_team_games = playoffs_teamgamelogs.info()
team_summary = team.TeamSummary(teamid, season=season)
team_summary_info = team_summary.info()
team_season_ranks = team_summary.season_ranks()
team_common_roster = team.TeamCommonRoster(teamid)
roster = team_common_roster.roster()
coaches = team_common_roster.coaches()
team_season = team.TeamSeasons(teamid)
team_season_info = team_season.info()
for i in team_season_info:
if (i["YEAR"] == season):
current_season_info = i
return render_template("teams.html",
title=team_summary_info[0]["TEAM_CITY"] + " " +
team_summary_info[0]["TEAM_NAME"],
teamid=teamid,
team_summary_info=team_summary_info,
team_season_ranks=team_season_ranks,
season=season,
team_games=team_games,
playoffs_team_games=playoffs_team_games,
current_season_info=current_season_info,
team_img=TEAM_ID_DATA)
def get_gameDataWithTeamsAndPoints(teamName, season):
teamsPlayingArray = []
teamPointsArray = []
team_id = TEAMS[teamName]['id']
df = team.TeamGameLogs(team_id, season).info()
gameIds = df["Game_ID"].values
# For each game get the teams who played and the points and add them to the dataframe line
i = 0
percentDone = 0
for matchup in df["MATCHUP"]:
print("%s %f " % (teamName, i / len(gameIds)))
teamsVector = np.zeros(2 * len(teamToIndex))
pointsVector = np.zeros(2 * len(teamToIndex))
team_stats = game.Boxscore(gameIds[i]).team_stats()
home = 0
if '@' in matchup:
home = 0
else:
home = 1
teams = matchup.split(" ")
## if(teams[0] not in teamToIndex.keys() or )
t1Index = teamToIndex[teams[0]]
t2Index = teamToIndex[teams[2]]
if (team_stats["TEAM_ID"].values[0] == teamName):
teamNamePoints = team_stats["PTS"].values[0]
otherPoints = team_stats["PTS"].values[1]
else:
teamNamePoints = team_stats["PTS"].values[1]
otherPoints = team_stats["PTS"].values[0]
if home:
teamsVector[t1Index] = 1
teamsVector[t2Index + len(teamToIndex)] = 1
pointsVector[t1Index] = teamNamePoints
pointsVector[t2Index + len(teamToIndex)] = otherPoints
else:
teamsVector[t2Index] = 1
teamsVector[t1Index + len(teamToIndex)] = 1
pointsVector[t2Index] = otherPoints
pointsVector[t1Index + len(teamToIndex)] = teamNamePoints
teamsPlayingArray.append(teamsVector)
teamPointsArray.append(pointsVector)
i += 1
df = df.assign(teams=pd.Series(teamsPlayingArray).values)
df = df.assign(points=pd.Series(teamPointsArray).values)
return df
def get_games_list(team_abbr):
gamelogs = team.TeamGameLogs(team_id=TEAMS[team_abbr]['id']).json
headers = gamelogs['resultSets'][0]['headers']
games_playbyplay = gamelogs['resultSets'][0]['rowSet']
game_id_list = []
for single_game in games_playbyplay:
game_id = single_game[1]
game_id_list.append(game_id)
return game_id_list
def load_custom_data(teamName, season, opponentTeam):
#df = team.TeamOpponentSplits(TEAMS[teamName]['id'],location='Home',season=get_season(season),
# opponent_team_id =TEAMS[opponentTeam]['id']).by_opponent()
df = game.BoxscoreSummary(game_id='0041400122').line_score()
#df = team.TeamGameLogs(TEAMS[teamName]['id'], get_season(season)).info()
lf = Scoreboard().east_conf_standings_by_day()
#df = team.TeamYearOverYearSplits(TEAMS[teamName]['id'], measure_type='Advanced',season=get_season(season), opponent_team_id =TEAMS[opponentTeam]['id']).by_year()
#df = team.TeamOpponentSplits(TEAMS[teamName]['id'], measure_type='Advanced', season=get_season(season), opponent_team_id=TEAMS[opponentTeam]['id']).by_opponent()
print(list(lf))
print(lf)
print(list(df))
print(df)
#print(list(df))
#return df
df1 = team.TeamGameLogs(TEAMS[teamName]['id'], get_season(season)).info()
#df1 = team.TeamLineups(TEAMS['MIL']['id']).overall()
print(list(df1))
return df1
def load_team_game_logs(self):
print("saving team game logs to database")
print("=================================")
for season in self.seasons:
for team in TEAMS.itervalues():
# check if logs already stored
if self.db.team_game_logs.count({"SEASON_ID": season_to_season_id(season),
"TEAM_ID": team['id']}) > 0:
print("team game logs for {} {} already exists, skipping".format(season, team['name']))
continue
print("storing team game logs for {} {}".format(season, team['name']))
ap = nba_py_team.TeamGameLogs(team_id=team['id'], season=season)
results = ap.info()
if isinstance(results, pandas.DataFrame):
results = results.to_dict("records")
for result in results:
result['SEASON_ID'] = season_to_season_id(season)
result['TEAM_ID'] = str(result['Team_ID'])
del result['Team_ID']
self.db.team_game_logs.insert_many(results)
def load_player_game_data_at_year(teamName, year):
teamId = TEAMS[teamName]['id']
season = get_season(year)
gameData = team.TeamGameLogs(teamId, season).info()
playerData = pd.DataFrame()
header = ['GAME_ID', 'TEAM_ID', 'PLAYER_ID', 'START_POSITION',
'MIN', 'FGM', 'FGA', 'FG_PCT', 'FG3M', 'FG3A', 'FG3_PCT',
'FTM', 'FTA', 'FT_PCT', 'OREB', 'DREB', 'REB', 'AST', 'STL',
'BLK', 'TO', 'PF', 'PTS', 'PLUS_MINUS']
visited = set()
i = 1
for g in gameData["Game_ID"]:
print(i)
i += 1
if (g in visited):
continue
visited.add(g)
temp = game.Boxscore(g).player_stats()
temp = temp[header]
playerData = playerData.append(temp)
time.sleep(5)
return playerData
def testAll(self):
assert team.TeamList()
assert team.TeamSummary(self.teamId)
team_details = team.TeamDetails(self.teamId)
assert team_details
# assert team_details.background()
# assert team_details.history()
assert team.TeamCommonRoster(self.teamId)
assert team.TeamGeneralSplits(self.teamId)
assert team.TeamOpponentSplits(self.teamId)
assert team.TeamLastNGamesSplits(self.teamId)
assert team.TeamInGameSplits(self.teamId)
assert team.TeamClutchSplits(self.teamId)
assert team.TeamShootingSplits(self.teamId)
assert team.TeamPerformanceSplits(self.teamId)
assert team.TeamLineups(self.teamId)
assert team.TeamPlayers(self.teamId)
assert team.TeamPlayerOnOffDetail(self.teamId)
assert team.TeamPlayerOnOffSummary(self.teamId)
assert team.TeamGameLogs(self.teamId)
assert team.TeamShotTracking(self.teamId)
assert team.TeamReboundTracking(self.teamId)
assert team.TeamPassTracking(self.teamId)
assert team.TeamVsPlayer(self.teamId, self.playerId)
def get_teamBoxScore(teamName, season):
#Use nba_py to load data
team_id = TEAMS[teamName]['id']
df = team.TeamGameLogs(team_id, season).info()
#print("game_logs:::",df)
return df
seasonid = int(season[:4] + season[-2:])
#if 1:
print('\nQuerying Team Data...')
start_time = time.time()
game_list = pd.DataFrame()
# Loop through teams here
for teamid in team_list.index:
if teamid:
#error_ct = 0
#while error_ct < 3:
#try:
print(' Querying ' + team_list.ix[teamid].TEAM_NAME + ' data...')
game_temp = team.TeamGameLogs(teamid, season=season).info()
'''
error_ct = 3
except:
print ' Failed!'
error_ct += 1
time.sleep(1)
'''
game_temp.set_index('Game_ID', inplace=True)
# Add Home Game flag for unique games
mask = game_temp.MATCHUP.str.contains('vs.')
game_temp['Home_Flag'] = mask.astype(int)
team_list = team.TeamList().info(
) # retrieve list of dicts that stores team info
# store game logs for each team in json file
for t in team_list:
if t['ABBREVIATION'] is None:
continue
filepath = "team_stats_2010/" + t['ABBREVIATION'] + '.json'
print(filepath)
logs = None
for year in range(2010, int(t['MAX_YEAR']) + 1):
next_year = str((year + 1) % 100)
if len(next_year) == 1:
next_year = '0' + next_year
season = str(year) + '-' + next_year
print(season)
season_log = team.TeamGameLogs(t['TEAM_ID'], season=season).info()
if not logs:
logs = season_log
else:
logs += season_log
with open(filepath, 'w') as f:
json.dump(logs, f)
