def pull_data(self):
data = playergamelog.PlayerGameLog(self.player, season=self.season)
player_df = pd.DataFrame(data.get_normalized_dict()['PlayerGameLog'])
player_df['GAME_DATE'] = pd.to_datetime(player_df['GAME_DATE'])
player_df.sort_values(by='GAME_DATE', ascending=True, inplace=True)
player_df.drop('VIDEO_AVAILABLE', axis=1, inplace=True)
return player_df
def careerLog(cls, player):
try:
playerDetails = player.details()
findGames = playergamelog.PlayerGameLog(
player_id=playerDetails[ID], season=SeasonAll.all)
careerLog = findGames.get_data_frames()[0]
return careerLog
except:
return NA
def getGamesPlayed(lis, wkStart):
gp = pd.DataFrame(columns=['PlayerID', 'GTBP'])
for x in range(len(lis)):
df = pgl.PlayerGameLog(lis[x]).get_data_frames()[0]
df.GAME_DATE = pd.to_datetime(df.GAME_DATE)
df = df[df.GAME_DATE >= wkStart + timedelta(dateAdvance)]
gp = gp.append({'PlayerID': lis[x], 'GTBP': len(df)}, ignore_index=True)
Time.sleep(delay)
if x % 8 == 0:
print(str(x) + ' seconds has passed')
print()
return gp
def get_games(request):
if request.method == 'GET':
id = request.GET['id']
year = request.GET['season']
type = request.GET['seasonType']
games = playergamelog.PlayerGameLog(player_id=id,
season_all=year,
season_type_all_star=type)
games = games.get_normalized_json()
return HttpResponse(games) # Sending a success response
else:
return HttpResponse("Request method is not a GET")
def show_graph(player_name):
player_dict = players.get_players()
player_df = [player for player in player_dict if player['full_name'] == player_name][0]
player_id = player_df['id']
gamelog_player_all = playergamelog.PlayerGameLog(player_id=player_id, season = SeasonAll.all)
gamelog_player_all_df = gamelog_player_all.get_data_frames()[0]
fig, ax = plt.subplots()
ax.scatter(gamelog_player_all_df['FG3A'], gamelog_player_all_df['FG3M'], c='blue', alpha=0.5)
return fig
def get_gamelog_data(player_id):
df = playergamelog.PlayerGameLog(
player_id=player_id).get_data_frames()[0][[
'GAME_DATE', stat, 'MATCHUP', 'WL', 'FG_PCT'
]]
df = df.rename(columns={'WL': 'Win/Lose'})
df['size'] = df['FG_PCT'] * 10
df['date'] = pd.to_datetime(df['GAME_DATE'])
df = df.sort_values(by=['date'])
df['stat'] = stat
df['avg'] = df[stat].ewm(com=0.9).mean()
return df
def getStatsByPlayerAndGame(playerID, gameDate):
time.sleep(1)
games = playergamelog.PlayerGameLog(player_id=playerID)
#it returns a list
df = games.get_data_frames()[0]
df['GAME_DATE'] = pd.to_datetime(df['GAME_DATE'], utc=True)
#filter to just the correct date
df = df.loc[df['GAME_DATE'] == gameDate]
if (len(df) > 0):
df['PR'] = df['PTS'] + df['REB']
df['PRA'] = df['PTS'] + df['REB'] + df['AST']
df['BS'] = df['BLK'] + df['STL']
df['PR'] = df['PTS'] + df['REB']
df['RA'] = df['REB'] + df['AST']
return df.squeeze()
def __get9CatStats(player_name, type, season):
p_id = __getPlayerId(player_name)
p_gamelog = playergamelog.PlayerGameLog(player_id=p_id, season=season)
p_df = p_gamelog.get_data_frames()[0]
if type == 'total':
# this line extract all of the necessary counting stats from the sum
p_9cat = p_df[['PTS', 'STL', 'AST', 'BLK', 'REB', 'TOV', 'FG3M']].sum()
if type == 'average':
# this line gets the average of all counting stats
p_9cat = p_df[['PTS', 'STL', 'AST', 'BLK', 'REB', 'TOV',
'FG3M']].mean()
# these lines get percentages
p_9cat['FG%'] = (p_df['FGM'].sum()) / (p_df['FGA'].sum())
p_9cat['FT%'] = (p_df['FTM'].sum()) / (p_df['FTA'].sum())
p_9cat['GP'] = len(p_df)
return p_9cat
def getLastTwoWeeksAveragePoints_nbaapi(playerObj):
playerName = playerObj.name
dateIndex = 1 #counter to keep track of how many days back we are going
totalGamesPlayed = 0
totalFantasyPoints = 0
today = datetime.datetime.today().strftime('%m/%d/%Y')
dateToPull = (datetime.datetime.now() -
datetime.timedelta(14)).strftime('%m/%d/%Y')
nba_player = players.find_players_by_full_name(playerName)
playerId = None
if len(nba_player) != 1:
lastName = playerName[playerName.find(" ") + 1:]
firstName = playerName[0:playerName.find(" ")]
for tmp_player in nba_player:
if tmp_player['first_name'] == firstName and tmp_player[
'last_name'] == lastName:
playerId = tmp_player['id']
if playerId == None:
print "Unable to determine player id for {}".format(playerName)
#TODO - instead of using the static nba api should do dynamic to get these players ID and get their
return 0
else:
playerId = nba_player[0]['id']
attempts = 0
while attempts < 5:
try:
gameLog = playergamelog.PlayerGameLog(
playerId,
date_from_nullable=dateToPull,
date_to_nullable=today)
except:
print "nba api timed out, waiting 10 minutes then trying again. Attempt {} of 5".format(
attempts)
attempts += 1
time.sleep(600)
if gameLog == None:
raise Exception(
"NBA API still not working after 5 attempts and waiting 10 minutes, bailing"
)
gameLogDf = gameLog.get_data_frames()[0]
totalFantasyPoints = getFantasyPointsFromDF(gameLogDf)
if len(gameLogDf) == 0:
print "{} played 0 games!".format(playerName)
return 0
return totalFantasyPoints / len(gameLogDf)
def pts_of_player(player_id):
pts = 0
player_log = playergamelog.PlayerGameLog(
player_id).get_normalized_dict()["PlayerGameLog"]
player_log_by_date = [
stat for stat in player_log if
datetime.datetime.strptime(stat["GAME_DATE"], "%b %d, %Y") < date_time
]
pts += np.sum([stat["AST"] for stat in player_log_by_date])
pts += np.sum([stat["REB"] for stat in player_log_by_date])
pts += np.sum([stat["PTS"] for stat in player_log_by_date])
pts += np.sum([stat["BLK"] for stat in player_log_by_date])
pts += np.sum([stat["STL"] for stat in player_log_by_date])
pts += np.sum([stat["PTS"] for stat in player_log_by_date]) / np.sum(
[stat["MIN"] for stat in player_log_by_date])
return pts / 100
def get_player_stats_detail(player_name):
player_dict = players.get_players()
player_df = [player for player in player_dict if player['full_name'] == player_name][0]
player_id = player_df['id']
gamelog_player_all = playergamelog.PlayerGameLog(player_id=player_id, season = SeasonAll.all)
gamelog_player_all_df = gamelog_player_all.get_data_frames()[0]
gamelog_player_all_df = gamelog_player_all_df[['GAME_DATE', 'MATCHUP', 'WL', 'MIN', 'FGM', 'FGA', 'FG_PCT', 'FG3M', 'FG3A', 'FG3_PCT', 'FTM', 'FTA', 'FT_PCT', 'OREB', 'DREB', 'REB', 'AST', 'STL', 'BLK', 'TOV', 'PTS']]
gamelog_player_all_df = gamelog_player_all_df.rename(columns = {'GAME_DATE':'Game Date', 'FG_PCT' : 'FG %', 'FG3_PCT':'FG3 %', 'FT_PCT':'FT %'})
gamelog_player_all_df['FG %'] = pd.Series(["{0:.2f}%".format(val * 100) for val in gamelog_player_all_df['FG %']], index = gamelog_player_all_df.index)
gamelog_player_all_df['FG3 %'] = pd.Series(["{0:.2f}%".format(val * 100) for val in gamelog_player_all_df['FG3 %']], index = gamelog_player_all_df.index)
gamelog_player_all_df['FT %'] = pd.Series(["{0:.2f}%".format(val * 100) for val in gamelog_player_all_df['FT %']], index = gamelog_player_all_df.index)
return gamelog_player_all_df
def player_average_9cat_stats(player_name, player_data_dict):
# Get player identifier
player_name_dict = [
player for player in player_data_dict
if player[DISPLAY_FIRST_LAST] == player_name
]
player_id = player_name_dict[0][PERSON_ID_KEY]
# Player game log
player_game_log = playergamelog.PlayerGameLog(player_id=player_id,
season=SEASON_2020)
nba_cooldown = random.gammavariate(alpha=9, beta=0.4)
time.sleep(nba_cooldown)
player_game_log_dataframe = player_game_log.get_data_frames()[0]
# Filter for games played
player_game_log_dataframe = \
player_game_log_dataframe[player_game_log_dataframe[MINUTES_COLUMN] >= 1]
# Find true percentages
player_game_log_dataframe = player_game_log_dataframe[CALCULATING_COLUMNS]
player_game_log_dataframe.loc[MEAN_ROW] = player_game_log_dataframe.mean()
player_game_log_dataframe = true_percentage(player_game_log_dataframe,
FIELD_GOAL_PERCENTAGE_COLUMN)
player_game_log_dataframe = true_percentage(player_game_log_dataframe,
FREE_THROW_PERCENTAGE_COLUMN)
# Filter for 9cat columns
player_9cat = player_game_log_dataframe[NINE_CAT_COLUMNS]
# Formatting columns
player_9cat = format_dataframe_decimals(player_9cat)
# Show only averages
player_9cat_season_average = pd.DataFrame(player_9cat.loc[MEAN_ROW]).T
# Add player name/games player
player_9cat_season_average[PLAYER_COLUMN] = player_name
player_9cat_season_average[GAMES_PLAYED] = len(player_game_log_dataframe)
# Move PLAYER NAME column
move_column_inplace(player_9cat_season_average, PLAYER_COLUMN, 0)
return player_9cat_season_average
def get_winning_stats_per_team(team):
fp = franchiseplayers.FranchisePlayers(team_id=team_to_id[team],
headers=headers)
PLAYERS = fp.get_data_frames()[0]
# Build the list of players in the 2019-2020 season
active_players = PLAYERS.loc[PLAYERS['ACTIVE_WITH_TEAM'] == 1]
ids_per_team = active_players['PERSON_ID'].values
player_names = active_players['PLAYER'].values
print(player_names)
players_per_team = dict(zip(ids_per_team, player_names))
effectiveness = []
players = []
## Get the winning_stats_for a player
for player in players_per_team:
pgl = playergamelog.PlayerGameLog(player_id=player, headers=headers)
player_game_data = pgl.get_data_frames()[0]
effectiveness.append(determine_player_winning_score(player_game_data))
players.append(players_per_team[player])
plot_stats_to_winning(player_game_data, players_per_team[player])
effect = dict(zip(effectiveness, players))
rank_player_winning_scores(team, effect, 5)
def playerstatpull(player, teamabb, season=2020): #Pull a players boxscore stats in a season for regression by name TODO automate teamabb lookup DOESNT WORK FOR ROOKIES
players=commonallplayers.CommonAllPlayers().get_data_frames()
players=players[0]
listofnames=players['DISPLAY_FIRST_LAST']
index=((list(listofnames)).index(player))
ID= (players.loc[index,'PERSON_ID'])
bs=playergamelog.PlayerGameLog(player_id=ID,season=season)
df=bs.get_data_frames()
df=df[0]
sumplusminus=[]
plusminus=0
for i in range (len(df)): ###lookupgame, sum plus minus of rest, append to list
game=boxscoretraditionalv2.BoxScoreTraditionalV2(game_id=df.loc[i][2])
game=(game.get_data_frames())[0]
for j in range (len(game)): #TODO clean this up
if game["TEAM_ABBREVIATION"][j]==teamabb and game["PLAYER_ID"][j]!=ID:
if not math.isnan(game["PLUS_MINUS"][j]): ##filters out do not play could be done better
plusminus+=game["PLUS_MINUS"][j]
sumplusminus.append(plusminus)
plusminus=0
time.sleep(1) #avoid timeout from api
df['teamplusminus']=sumplusminus
return df
def get_every_game_season(self, player_id, season_dict, season_games_dict):
# go through every season for a player, get all of the games
name = players.find_player_by_id(player_id)['full_name']
res = []
for year in season_dict[player_id]:
# http request is made here
player_season = playergamelog.PlayerGameLog(player_id, season=year)
print(f'{name} - {year}')
# ignore empty data
if player_season.player_game_log.data['data'] != []:
# played some time
# all games in a season
for game in player_season.player_game_log.data['data']:
temp = []
for i in range(3, 25):
# indices 3 to 25 give the important stats
temp.append(game[i])
res.append(temp)
player_dict = {player_id: res}
season_games_dict.update(player_dict)
# update shared dictionary
print(f'{name} processed.')
data_dict[new] = data_dict[old]
del data_dict[old]
nba_players = players.get_players()
time.sleep(0.5)
for i in data_dict.keys():
if (data_dict[i][4] != 0) and (data_dict[i][5] != 'O'):
print('--------------------------------------------------')
print(i)
try:
pl = [
player for player in nba_players if player['full_name'] == i
][0]['id']
log_all = playergamelog.PlayerGameLog(
player_id=pl).get_data_frames()[0]
time.sleep(0.5)
log_x = playergamelog.PlayerGameLog(
player_id=pl).get_data_frames()[0][0:last_x]
time.sleep(0.5)
# STANDARD DEVIATION CALCULATION
log_lst = []
for ind, row in log_all.iterrows():
log_fp = row['PTS'] + (row['FG3M'] * .5) + (
row['REB'] * 1.25) + (row['AST'] * 1.5) + (
(row['STL'] + row['BLK']) * 2) - (row['TOV'] * .5)
DD_TD = 0
if row['PTS'] >= 10: DD_TD += 1
with open('data.json', 'w') as fp:
json.dump(player_info, fp, indent=4)
atexit.register(save_data)
FROM_DATE = "01/01/2020"
TO_DATE = "02/26/2020"
# Count id
id = 0
for player in player_info_raw:
try:
# Create game data
sleep(0.5)
game_log = playergamelog.PlayerGameLog(player_id=player['id'], timeout=300, date_from_nullable=FROM_DATE, date_to_nullable=TO_DATE).get_normalized_dict()["PlayerGameLog"]
if len(game_log) == 0:
continue
games = []
for idx, game in enumerate(game_log):
games.append({
"id": idx,
"matchup": game["MATCHUP"],
"result": game["WL"],
"pts": game["PTS"],
"ast": game["AST"],
"reb": game["REB"]
})
# Get player's info
sleep(0.5)
rosters.append(rosters_dict["data"])
#get playerstats
leaguestats = leaguedashplayerstats.LeagueDashPlayerStats(
per_mode_detailed="PerGame", season="2018-19")
leaguestats = leaguestats.league_dash_player_stats.get_dict()
leaguestats = leaguestats["data"]
leaguestats.sort(key=lambda x: x[0])
leaguestats_length = len(leaguestats) - 1
sql = "CREATE TABLE IF NOT EXISTS playergamelog (seasonid INT, playerid INT, gameid INT, gamedate DATE, matchup VARCHAR(255), win VARCHAR(255),min INT,"
sql += "fgm INT, fga INT, fg_pct DECIMAL(4,3), fg3m INT, fg3a INT, fg3_pct DECIMAL(4,3), ftm INT, fta INT, ft_pct DECIMAL(4,3), oreb INt, dreb INT, reb INT,"
sql += "ast INT, stl INT, blk INT, tov INT, pf INT, pts INT, plusminus INT, PRIMARY KEY (playerid, gamedate))"
cursor.execute(sql)
for player in leaguestats:
player_stats = playergamelog.PlayerGameLog(player_id=player[0],
season="2018-19")
time.sleep(2)
player_stats = player_stats.player_game_log.get_data_frame()
for index, game in player_stats.iterrows():
sql = "INSERT INTO playergamelog (seasonid,playerid,gameid,gamedate,matchup,win,min,fgm,fga,fg_pct,fg3m,fg3a,fg3_pct,ftm,fta,ft_pct,oreb,dreb,reb,ast,stl,blk,tov,pf,pts,plusminus) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) ON DUPLICATE KEY UPDATE seasonid = %s"
values = ()
for i in range(len(game) - 1):
if (i == 3):
game[i] = datetime.datetime.strptime(game[i], '%b %d, %Y')
values = values + (game[i], )
values = values + (game[0], )
cursor.execute(sql, values)
db.commit()
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")
boxscore.get_data_frames()[0]
## based on teamgamelog and box score, we could calculate the FPPM for each player
## but how to link games to players? have to go through team?
from nba_api.stats.endpoints import playergamelog
gamelog = playergamelog.PlayerGameLog(player_id="203999", season="2018-19")
gamelog.get_data_frames()[0]
# does it include DNPs?
### seems it does not
### One(?) does have to create a class that returns relevant FPs for a given player
## and game number (Nikola Vucevic, game 35)
def __getPlayerStats(playerID: str, year: int) -> DataFrame.__class__:
gamelog = playergamelog.PlayerGameLog(player_id=playerID, season=str(year))
return gamelog.get_data_frames()[0]
from nba_api.stats.endpoints import playercareerstats, playergamelog
import pandas as pd
import numpy as np
import datetime
# Myles Turner Bubble Stats
# career = playercareerstats.PlayerCareerStats(player_id='1626167')
# career = career.get_data_frames()[0]
domas_games = playergamelog.PlayerGameLog(player_id="1627734", season="ALL")
domas_games = domas_games.get_data_frames()[0]
myles_games = playergamelog.PlayerGameLog(player_id="1626167", season="ALL")
myles_games = myles_games.get_data_frames()[0]
for i in myles_games.Game_ID:
for j in domas_games.Game_ID:
if (i == j):
myles_games = myles_games[myles_games.Game_ID != i]
pacers_playoffs = playergamelog.PlayerGameLog(player_id="1626167",
season="ALL",
season_type_all_star="Playoffs")
pacers_playoffs = pacers_playoffs.get_data_frames()[0]
myles_games = pd.concat([pacers_playoffs, myles_games])
new_dates = []
for i in myles_games.GAME_DATE:
i = datetime.datetime.strptime(i, '%b %d, %Y')
new_dates.append(i)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from nba_api.stats.library.parameters import SeasonAll
from nba_api.stats.endpoints import playergamelog
import pandas as pd
gamelog_bron_all = playergamelog.PlayerGameLog(player_id='2544',
season=SeasonAll.all)
df_bron_games_all = gamelog_bron_all.get_data_frames()[0]
df_bron_games_all.to_csv(path_or_buf="lebronAll.csv")
# import nba_api as nba
# pbp = nba_st_end.playbyplay.PlayByPlay('0021701171')
# pbp = pbp.get_data_frames()[0]
# print (pbp)
from nba_api.stats.static import players
from nba_api.stats.static import teams
from nba_api.stats.endpoints import leaguegamefinder
from nba_api.stats.endpoints import playbyplayv2
from nba_api.stats.endpoints import commonplayerinfo
from nba_api.stats.endpoints import playergamelog
playerid = players.find_players_by_full_name('Damian Lillard')[0]['id']
gamefinder = leaguegamefinder.LeagueGameFinder(player_id_nullable=playerid)
plays_for = commonplayerinfo.CommonPlayerInfo(
player_id=playerid).get_data_frames()[0].at[0, 'TEAM_ABBREVIATION']
score = playergamelog.PlayerGameLog(season_all="ALL", player_id=playerid)
againstTeam = {}
for team in teams.get_teams():
againstTeam[team['abbreviation']] = 0
for i in range(len(games.index)):
print(i)
pbp = playbyplayv2.PlayByPlayV2(games.at[i, 'GAME_ID'])
pbp = pbp.get_data_frames()[0]
match = games.at[i, 'MATCHUP']
if ("@ " + plays_for in match) or (plays_for + " vs." in match):
home = True
else:
home = False
import seaborn as sns
import matplotlib.pyplot as plt
import time
# Get LeBron James player ID
# https://github.com/swar/nba_api/blob/master/docs/nba_api/stats/static/players.md
lbj_dict = players.find_players_by_full_name('LeBron James')
lbj_id = lbj_dict[0]['id']
# Using ID, get LeBron's game logs
# https://github.com/swar/nba_api/blob/master/docs/nba_api/stats/endpoints/playergamelog.md
# Test on 2018-19
lbj_game_log_1819 = playergamelog.PlayerGameLog(
player_id=lbj_id,
season_all='2018-19',
season_type_all_star='Regular Season')
lbj_game_log_1819_df = lbj_game_log_1819.get_data_frames()[0]
lbj_1819_pts_by_game = (
lbj_game_log_1819_df.loc[:, ['GAME_DATE', 'PTS']].sort_values('GAME_DATE'))
"""
lbj_1819_pts_by_game
GAME_DATE PTS
26 DEC 02, 2018 22
25 DEC 05, 2018 42
24 DEC 07, 2018 35
23 DEC 08, 2018 20
22 DEC 10, 2018 28
21 DEC 13, 2018 29
20 DEC 15, 2018 24
19 DEC 16, 2018 13
from nba_api.stats.endpoints import playergamelog
from nba_api.stats.library.parameters import SeasonAll
import pandas as pd
#Call the API endpoint passing in lebron's ID & which season
gamelog = playergamelog.PlayerGameLog(player_id='1627763', season='2020')
gamelogAll = playergamelog.PlayerGameLog(player_id='1627763',
season=SeasonAll.all)
#Converts gamelog object into a pandas dataframe
#can also convert to JSON or dictionary
df = gamelogAll.get_data_frames()
print(df)
# # If you want all seasons, you must import the SeasonAll parameter
# from nba_api.stats.library.parameters import SeasonAll
# gamelog_bron_all = playergamelog.PlayerGameLog(player_id='2544', season = SeasonAll.all)
# df_bron_games_all = gamelog_bron_all.get_data_frames()
from nba_api.stats.endpoints import playergamelog, teamgamelog, playernextngames, leaguestandings
import statistics
r = 0
Play = ["DeMar DeRozan"]
li = [18.5]
for pl in Play:
Line = li[r]
name = pl
the_factor = 'null'
player_dict = players.get_active_players()
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,
filename = filename + seasonToGrab + '-CombinedPlayerBoxScores.csv'
######Create the dataframe by loading in a player outside of the loop
player_dict = players.get_players()
time.sleep(2)
#Loop through player listing
df_player_games_total = pd.DataFrame()
# Use ternary operator or write function
# Names are case sensitive
player = [
player for player in player_dict
if player['full_name'] == 'Tristan Thompson'
][0]
player_id = player['id']
#Call the API endpoint passing in lebron's ID & which season
gamelog_player = playergamelog.PlayerGameLog(player_id=player_id,
season=seasonToGrab)
time.sleep(2)
#Converts gamelog object into a pandas dataframe
#can also convert to JSON or dictionary
df_player_games = gamelog_player.get_data_frames()[0]
df_player_games.insert(2, 'Player_Name', 'Tristan Thompson')
df_player_games_total = df_player_games
time.sleep(2)
######
#####Loop through list of players and append together
for i in playerList:
# Use ternary operator or write function
# Names are case sensitive
player = [player for player in player_dict if player['full_name'] == i][0]
player_id = player['id']
