def __get_team_gamelog(self, team_id):
"""Hidden method to get a given team's gamelog
Args:
team_id (int): Team ID
Returns:
pd.DataFrame: Team's gamelog and game number
"""
team_gamelog = teamgamelog.TeamGameLog(team_id=team_id)
logger.debug("Getting teams gamelogs")
team_gamelog = team_gamelog.get_data_frames()[0]
team_gamelog["GAME_DATE"] = pd.to_datetime(team_gamelog["GAME_DATE"])
team_gamelog = team_gamelog.sort_values("GAME_DATE")
team_gamelog = team_gamelog.reset_index()
team_gamelog = team_gamelog.drop(["index"], axis=1)
team_gamelog.loc[:, "GAME_NUMBER"] = team_gamelog.index + 1
cols_to_keep = [
"Team_ID",
"Game_ID",
"GAME_DATE",
"MATCHUP",
"GAME_NUMBER",
"WL",
]
team_gamelog = team_gamelog[cols_to_keep]
return team_gamelog
def get_games_api(team_ids):
print("Loading game lists...")
team_games = []
all_games = []
for tid in team_ids:
team_log = teamgamelog.TeamGameLog(season=SEASON,
season_type_all_star=SEASON_TYPE,
team_id=tid).get_dict()
results = team_log["resultSets"][0]["rowSet"]
game_ids = [res[GAMELOG_GAME_ID_INDEX] for res in results]
dates = [
datetime.strptime(res[GAMELOG_DATE_INDEX].replace(",", ""),
"%b %d %Y") for res in results
]
for pair in zip(dates, game_ids):
bisect.insort_left(all_games, pair)
# Reverse the game id list!
team_games.append((tid, game_ids[::-1]))
name = teams.find_team_name_by_id(tid)["full_name"]
print(name + " done...")
# deduplicate games
all_games = OrderedDict((x, True) for x in all_games).keys()
return team_games, list(all_games)
def print_boxscore(team_abbr):
game_id = (teamgamelog.TeamGameLog(
teams.find_team_by_abbreviation(
team_abbr.lower())["id"]).get_data_frames()[0].iloc[0].Game_ID)
b = (boxscoretraditionalv2.BoxScoreTraditionalV2(
game_id).get_data_frames()[0].dropna())
b["PLAYER"] = b["PLAYER_NAME"].apply(
lambda s: s.ljust(b.PLAYER_NAME.str.len().max(), " "))
b.MIN = b.MIN.str.rjust(5, "0")
for field in ["FGM", "FGA", "FG3M", "FG3A", "FTM", "FTA"]:
b[field] = b[field].fillna(0).astype(int)
b["FG"] = (b["FGM"].map(str) + "-" + b["FGA"].map(str)).str.pad(5)
b["FG3"] = (b["FG3M"].map(str) + "-" + b["FG3A"].map(str)).str.pad(5)
b["FT"] = (b["FTM"].map(str) + "-" + b["FTA"].map(str)).str.pad(5)
for team_name, bscore in b.groupby("TEAM_ABBREVIATION"):
print(team_name)
tabulate.PRESERVE_WHITESPACE = True
outb = bscore[[
"PLAYER", "MIN", "FG", "FG3", "FT", "REB", "AST", "STL", "BLK",
"TO", "PF", "PTS"
]]
print(tabulate.tabulate(outb, headers="keys", showindex="never"))
tabulate.PRESERVE_WHITESPACE = False
def pts_of_team(team):
team_games = teamgamelog.TeamGameLog(
team_id=team["id"]).get_normalized_dict()["TeamGameLog"]
team_pct = [
game["W_PCT"] for game in team_games if
datetime.datetime.strptime(game["GAME_DATE"], "%b %d, %Y") <= date_time
][0]
return team_pct * 10
def get_season(self, season, season_type):
'''
'''
# - Overview of games including ids
# - team game log
log = teamgamelog.TeamGameLog(team_id=self.id,
season=season,
season_type_all_star=season_type)
return log.get_data_frames()[0]
def teamopponentstatpull(teamabb, season=2020): ##retrieve a team's entire opponent box scores over a season
team=teams.find_team_by_abbreviation(teamabb)
games=teamgamelog.TeamGameLog(team_id=team.get("id"),season=season)
games=(games.get_data_frames())[0]
gameids=games['Game_ID']
outcome=pd.DataFrame()
for i in range (len (gameids)):
temp=gamestatgen(gameids[i],teamabb)
outcome=outcome.append(temp)
outcome=outcome.dropna()
return outcome
def build_games_for_team(team):
gpbp = teamgamelog.TeamGameLog(team_id=team_to_id[team], headers=headers)
tgl = gpbp.get_data_frames()[0]
game_ids = tgl['Game_ID'].values
games = []
matchups = tgl['MATCHUP'].values
for i in range(len(matchups)):
curr = matchups[i]
is_home = True
if '@' in curr:
is_home = False
opponent = curr[-3:]
games.append((game_ids[i], is_home, opponent))
return games
def generate_win_probability_team(team, NUMBER_GAMES):
gpbp = teamgamelog.TeamGameLog(team_id=team_to_id[team], headers=headers)
tgl = gpbp.get_data_frames()[0]
games = tgl['Game_ID'].values
matchups = tgl['MATCHUP'].values
results = tgl['WL'].values
i = 0
selected_games = games[0:NUMBER_GAMES]
for game in selected_games:
wpp = winprobabilitypbp.WinProbabilityPBP(game_id=game, headers=headers)
wp = wpp.get_data_frames()[0]
plot_game_win_probability(wp, matchups[i])
print("This game resulted with %s getting the %s" % (team, results[i]))
print("====================================================================")
i += 1
def pts_of_matchup(team1, team2):
team_id = teams.find_teams_by_full_name(team1)[0]["id"]
team_games = teamgamelog.TeamGameLog(
team_id=team_id).get_normalized_dict()["TeamGameLog"]
opponent_abb = teams.find_teams_by_full_name(team2)[0]["abbreviation"]
games_by_opponent = [
game for game in team_games
if game["MATCHUP"].split(" ")[2] == opponent_abb and
datetime.datetime.strptime(game["GAME_DATE"], "%b %d, %Y") <= date_time
]
wins_by_opponent = [
game for game in games_by_opponent if game["WL"] == "W"
]
if games_by_opponent == []:
return 0
return (len(wins_by_opponent) / len(games_by_opponent)) * 10
def get_team_info(game_id, season, season_type):
# Create Box Score Traditional Object and get DataFrame
traditional = boxscoretraditionalv2.BoxScoreTraditionalV2(game_id=game_id)
teams_df = traditional.team_stats.get_data_frame()
# Determine The Two Teams That Played In The Game #
teams = teams_df['TEAM_ID'].unique()
### Figure Out Which Team Won The Game ###
# Create a game log object and dataframe for the first team in the teams list
game_log = teamgamelog.TeamGameLog(team_id=teams[0],
season=season,
season_type_all_star=season_type)
game_log_df = game_log.team_game_log.get_data_frame()
# Filter that teams game log to be only the specific game we are evaluating
game_log_df = game_log_df[game_log_df['Game_ID'] == game_id]
# Print basic info about the game for tracking purposes as code is running, game date, two teams playing, if first team won or lost game
print(game_log_df.iloc[0]['GAME_DATE'], " ",
game_log_df.iloc[0]['MATCHUP'], " ", game_log_df.iloc[0]['WL'])
# If team[0] won the game, set their id to the winning_team variable, else set team[1]
# If there is an @ the first team is away, else they are home. This is important for the play_by_play dataframe
if game_log_df.iloc[0]['WL'] == 'W' and '@' in game_log_df.iloc[0][
'MATCHUP']:
winning_team = teams[0]
losing_team = teams[1]
home_away = 1
elif game_log_df.iloc[0]['WL'] == 'W' and '@' not in game_log_df.iloc[0][
'MATCHUP']:
winning_team = teams[0]
losing_team = teams[1]
home_away = 0
elif game_log_df.iloc[0]['WL'] == 'L' and '@' not in game_log_df.iloc[0][
'MATCHUP']:
winning_team = teams[1]
losing_team = teams[0]
home_away = 1
else:
winning_team = teams[1]
losing_team = teams[0]
home_away = 0
return losing_team, winning_team, home_away
def getNbaScore():
nba_teams = teams.get_teams()
raptors = [team for team in nba_teams if team['abbreviation'] == 'TOR'][0]
raptors_id = raptors['id']
rapsGames = teamgamelog.TeamGameLog(team_id=raptors_id,
season_all="2018-19",
season_type_all_star='Regular Season')
mostRecentGame = pd.DataFrame(rapsGames.get_data_frames()[0]).iloc[0]
gameId = mostRecentGame['Game_ID']
matchup = mostRecentGame['MATCHUP']
win = mostRecentGame['WL']
wins = mostRecentGame['W']
losses = mostRecentGame['L']
torScore = mostRecentGame['PTS']
gamesResult = leaguegamefinder.LeagueGameFinder()
all_games = gamesResult.get_data_frames()[0]
opponentGame = all_games[all_games.GAME_ID == gameId]
opponentGame = opponentGame[
opponentGame['TEAM_ABBREVIATION'] != 'TOR'].iloc[0]
opponentScore = opponentGame['PTS']
gameDate = getDay(opponentGame['GAME_DATE'])
statsResult = teamplayerdashboard.TeamPlayerDashboard(team_id=raptors_id,
last_n_games=1)
playerStats = pd.DataFrame(statsResult.get_data_frames()[1])
key_player = playerStats.sort_values(by=['PTS'], ascending=False).iloc[0]
key_player_name = key_player['PLAYER_NAME']
key_player_pts = key_player['PTS']
key_player_ast = key_player['AST']
key_player_reb = key_player['REB']
return "Latest Game from {}: {}\nThe Raps took a {} making their record {}W / {}L \nScore: {} : {}\nKey Player: {}\nStats:\n\tPoints: {}\n\tAssists: {}\n\tRebounds: {}".format(
gameDate, matchup, win, wins, losses, torScore, opponentScore,
key_player_name, key_player_pts, key_player_ast, key_player_reb)
def build_table():
'''
Downloads statistics of non-play-off games per specified seasons per all commands as dataframes.
Per every game there is stat regarding both team. Dataframes are serialized and compiled to big one
'''
seasons = [
'2008-09', '2009-10', '2010-11', '2011-12', '2012-13', '2013-14',
'2014-15', '2015-16', '2016-17', '2017-18', '2018-19'
]
dir_path = "../data/all_games_per_seasone/"
nba_teams = teams.get_teams()
teams_fullnames_dict = {m['full_name']: m['id'] for m in nba_teams}
train_data = pd.DataFrame()
print("start")
for season in seasons:
season_data = pd.DataFrame()
print(season)
for name, team_id in teams_fullnames_dict.items():
print(name)
time.sleep(1)
season_team_data = teamgamelog.TeamGameLog(
team_id, season_all=season).get_data_frames()[0]
season_data = season_data.append(season_team_data)
season_data.sort_values(by=['Game_ID'], inplace=True)
season_data.reset_index(drop=True, inplace=True)
serialize(data=season_data, dir_path=dir_path, filename=season)
train_data = train_data.append(season_data, )
train_data.reset_index(drop=True, inplace=True)
serialize(data=train_data, dir_path=dir_path, filename="all_seasons")
return train_data
for player in player_dict:
if player['full_name'] == name:
the_factor = player['id']
gamelog = playergamelog.PlayerGameLog(player_id=the_factor, season='2020')
df = gamelog.get_data_frames()
str_matchup = str(df[0].MATCHUP[0])
str_matchup = str_matchup[:-2]
the_team_factor = 'null'
team_dict = teams.get_teams()
for team in team_dict:
if team['abbreviation'] in str_matchup:
the_team_factor = team['id']
team_game_log = teamgamelog.TeamGameLog(team_id=the_team_factor,
season='2020')
tdf = team_game_log.get_data_frames()
next_games = playernextngames.PlayerNextNGames(player_id=the_factor,
number_of_games='1')
ndf = next_games.get_data_frames()
oppo_stats = leaguestandings.LeagueStandings(league_id='00', season='2020')
odf = oppo_stats.get_data_frames()
PTS = df[0].PTS
def PTS_TO_LINE(PTS, line):
avg = sum(PTS) / len(PTS)
std = statistics.stdev(PTS)
if line < avg and line > avg - std:
import os
from nba_api.stats.static import teams
from nba_api.stats.endpoints import teamgamelog
import pandas as pd
teamsList = teams.get_teams()
abbrNameTransList = {}
teamGameLogs = {}
for x in teamsList:
abbrNameTransList[x['abbreviation']] = x['full_name']
print(x['abbreviation'])
teamGameLogs[x['abbreviation']] = (teamgamelog.TeamGameLog(x['id']))
print(teamsList)
df = pd.DataFrame()
for key, value in teamGameLogs.items():
df = df.append(pd.DataFrame(value.team_game_log.get_data_frame()),
ignore_index=True)
homeDf = df.loc[df['MATCHUP'].str.contains('@')]
homeDf[['team', 'ignore']] = homeDf['MATCHUP'].str.split(' @ ', expand=True)
awayDf = df.loc[df['MATCHUP'].str.contains(' vs. ')]
awayDf[['team', 'ignore']] = awayDf['MATCHUP'].str.split(' vs. ', expand=True)
matchupDF = homeDf.merge(awayDf,
how="inner",
on="Game_ID",
suffixes=('_away', '_home'))
matchupDF['abbr_home'] = matchupDF['team_home']
#print(df_teamStats) #Check if data frame is correctly filled
df_teamStats.to_pickle(
"/Users/anshumandash/nba_analysis_project/df_teamStats.pkl")
df_season_game_log = pd.DataFrame()
for i in range(0, len(df_teamStats), 1):
#for i in range(0,2,1):
#nbaTeamStatsDataFrame = df_teamStats.loc[[i],["TEAM_ID","TEAM_NAME","GP","PTS"]] These work right now
#print(nbaTeamStatsDataFrame)
nbaTeamID = df_teamStats.loc[i]['TEAM_ID']
nbaSeasonGameLog = teamgamelog.TeamGameLog(
season="2019-20",
team_id=nbaTeamID,
season_type_all_star="Regular Season")
df2 = nbaSeasonGameLog.get_data_frames()[0]
df_season_game_log = df_season_game_log.append(
pd.DataFrame(df2)
) #https://stackoverflow.com/questions/37009287/using-pandas-append-within-for-loop/37009377
df_season_game_log.to_pickle(
"/Users/anshumandash/nba_analysis_project/df_season_game_log.pkl")
#print(df_season_game_log)
summaryBoxScoreDataFrame = pd.DataFrame()
filtered_df_season_game_log = df_season_game_log.drop_duplicates(
subset=['Game_ID']).reset_index(drop=True)
p += 1
else:
team1_Score += (max_points - (i * points_change))
team2_Score += (max_points - (i * points_change))
o += 1
p += 1
#getting team IDs given the names seen above
Team1 = [x for x in teams if x['full_name'] == a][0]
Team1_id = Team1['id']
Team2 = [x for x in teams if x['full_name'] == b][0]
Team2_id = Team2['id']
#find games played by a team, to see stats for the team for a given season
Team1_Current = teamgamelog.TeamGameLog(Team1_id).get_data_frames()[0]
Team2_Current = teamgamelog.TeamGameLog(Team2_id).get_data_frames()[0]
#find current roster for each team
Team1_Roster = commonteamroster.CommonTeamRoster(Team1_id).get_data_frames()[0]
Team2_Roster = commonteamroster.CommonTeamRoster(Team2_id).get_data_frames()[0]
#find player ids for everyone on both teams
Team1_PlayerIds = Team1_Roster[['PLAYER_ID']]
Team1_PlayerIds = convert(Team1_PlayerIds, 'PLAYER_ID')
Team2_PlayerIds = Team2_Roster[['PLAYER_ID']]
Team2_PlayerIds = convert(Team2_PlayerIds, 'PLAYER_ID')
#determining the lenght of each team
Team1_length = len(Team1_PlayerIds)
from nba_api.stats.endpoints import teamgamelog
from nba_api.stats.static import teams
team = teams.get_teams()
for t in team:
data = teamgamelog.TeamGameLog(team_id=t['id']).team_game_log.get_data_frame()
print(data)
per_mode36='PerGame',
player_id=playerData).season_totals_regular_season.get_data_frame(
)
dt = datetime.datetime(date[0], date[1], date[2])
if len(str(date[2])) == 1:
hurtDay = '0' + str(date[2])
else:
hurtDay = str(date[2])
if date[1] >= 10:
seasonDate = f'{date[0]}-{str(date[0]+1)}'.replace('20', '')
else:
seasonDate = f'{date[0]-1}-{str(date[0])}'.replace('20', '')
playerInfo = playerInfo[playerInfo['SEASON_ID'] == seasonDate]
try:
seasonSchedule = teamgamelog.TeamGameLog(
season=seasonDate, team_id=playerInfo.iloc[0]
['TEAM_ID']).team_game_log.get_data_frame()
missedGame = seasonSchedule[
seasonSchedule['GAME_DATE'] ==
f'{dt.strftime("%b").upper()} {hurtDay}, {date[0]}']
#print(missedGame)
prevGames = []
for prevDate in range(1, 8):
prevD = dt - datetime.timedelta(prevDate)
prevGame = seasonSchedule[
seasonSchedule['GAME_DATE'] ==
f'{prevD.strftime("%b %d, %Y").upper()}']
try:
prevGame.iloc[0]['Game_ID']
prevGames.append(prevGame)
except:
'Accept': 'application/json, text/plain, */*',
'Accept-Language': 'en-US,en;q=0.5',
'Referer': 'https://stats.nba.com/',
'Accept-Encoding': 'gzip, deflate, br',
'Connection': 'keep-alive',
}
# getting dictionary of all teams
teams_dict = teams.get_teams()
# getting the lakers 2020 game log
lakers = [
team for team in teams_dict if team["full_name"] == "Los Angeles Lakers"
][0]
lakersGameLog = teamgamelog.TeamGameLog(
team_id=lakers['id'],
season="2019-20",
season_type_all_star="Regular Season").get_data_frames()[0]
# getting the clippers 2020 game log
clippers = [
team for team in teams_dict if team["full_name"] == "Los Angeles Clippers"
][0]
clippersGameLog = teamgamelog.TeamGameLog(
team_id=clippers['id'],
season="2019-20",
season_type_all_star="Regular Season").get_data_frames()[0]
# extracting the data for points scored for each team
lakers2020Points = [pts for pts in lakersGameLog['PTS']]
totalLakersPoints = 0
from NBA_Player.statistics import Statistics
from NBA_Player.box_scores import BoxScores
# To check what these sets of data offer offer (which variables I can use)
teams_dict = teams.get_teams()
team_details = [team for team in teams_dict]
data = endpoints.leagueleaders.LeagueLeaders(stat_category_abbreviation='FGA')
leaders = data.league_leaders.get_data_frame()
lakers = [
team for team in teams_dict if team["full_name"] == "Los Angeles Lakers"
][0]
player_dict = players.get_players()
lakersStats = teamyearbyyearstats.TeamYearByYearStats(
team_id=lakers['id']).get_data_frames()[0]
lakersRegularSznGameLog = teamgamelog.TeamGameLog(
team_id=lakers['id'],
season="2019-20",
season_type_all_star="Regular Season").get_data_frames()[0]
# Linear regression model class can take in two viable variables and creates
# a linear regression graph plotting them against each other
# model1 = RegressionModel('PTS', 'AST', 'AST', [1, 2, 5, 8, 12])
# model1.draw()
# Creating an NBA Player using class
lebron = NBAPlayer(fullname='LeBron James',
playerTeam="Los Angeles Lakers",
opponentTeam="Golden State Warriors")
# Can get career / season wide box score logs
lbjCareerBoxScores = BoxScores.careerLog(player=lebron)
lbj2020BoxScores = BoxScores.seasonLog(player=lebron, season="2019")
def get_team_game_log(team_id, year):
return teamgamelog.TeamGameLog(team_id=team_id,
season=year).get_data_frames()[0]
from nba_api.stats.endpoints import teamgamelog
import pandas as pd
import time
# load team and players dfs
nba_teams_df = pd.read_csv('nba_teams_df.csv')
nba_players_df = pd.read_csv('nba_players_df.csv')
# Season.default = '2019-20'
appended_data = []
for i in range(0, len(nba_teams_df)):
print('Getting team log for ' + nba_teams_df['Full_name'][i] + ' ...')
appended_data.append(pd.DataFrame(teamgamelog.TeamGameLog(team_id=nba_teams_df['ID'][i]).get_data_frames()[0]))
time.sleep(10)
all_game_data = pd.concat(appended_data)
# write to csv
all_game_data.to_csv('2019_20_all_game_data.csv', index=False)
from nba_api.stats.static import players
nba_players = players.get_players()
nba_players[:3]
kareem = playercareerstats.PlayerCareerStats(player_id="76003")
kareem.get_data_frames()[0]
### get all games from a team (current season, Atlanta 1610612737)
from nba_api.stats.endpoints import teamgamelog
gamelog = teamgamelog.TeamGameLog(team_id="1610612737")
gamelog.get_data_frames()[0]
## get play by play from desired game (0021900543 ATL vs DEN)
from nba_api.stats.endpoints import playbyplay
gamepbp = playbyplay.PlayByPlay(game_id="0021900543")
gamepbp.get_data_frames()[0].sort_values("EVENTNUM")
## get traditional box score from the same game
from nba_api.stats.endpoints import boxscoretraditionalv2
boxscore = boxscoretraditionalv2.BoxScoreTraditionalV2(game_id="0021900543")