def search2():
"""Search post request when searching for a specific player or team.
"""
name = request.form["searchname"]
name2 = request.form["searchname2"]
get_player1 = False
get_player2 = False
fullname = name.lower()
player = playersapi.find_players_by_full_name(fullname)
try:
getplayerid = player[0]['id']
get_player1 = True
except:
get_player1 = False
fullname = name2.lower()
player = playersapi.find_players_by_full_name(fullname)
try:
getplayerid2 = player[0]['id']
get_player2 = True
except:
get_player2 = False
if get_player1 == True and get_player2 == True:
return redirect(
url_for("player_vs_player",
playerid=getplayerid,
playerid2=getplayerid2))
else:
return render_template("search.html")
def submitMatchup(self):
# gets user's lineup from entry boxes and puts players into list
pg = self.entryPG.get()
sg = self.entrySG.get()
sf = self.entrySF.get()
pf = self.entryPF.get()
c = self.entryC.get()
g = self.entryG.get()
f = self.entryF.get()
util1 = self.entryUtil1.get()
util2 = self.entryUtil2.get()
util3 = self.entryUtil3.get()
lineup = [pg, sg, sf, pf, c, g, f, util1, util2, util3]
# gets opp's lineup from entry boxes and puts players into list
oppPG = self.entryOppPG.get()
oppSG = self.entryOppSG.get()
oppSF = self.entryOppSF.get()
oppPF = self.entryOppPF.get()
oppC = self.entryOppC.get()
oppG = self.entryOppG.get()
oppF = self.entryOppF.get()
oppUtil1 = self.entryOppUtil1.get()
oppUtil2 = self.entryOppUtil2.get()
oppUtil3 = self.entryOppUtil3.get()
oppLineup = [
oppPG, oppSG, oppSF, oppPF, oppC, oppG, oppF, oppUtil1, oppUtil2,
oppUtil3
]
# creates list of player ID's in lineup
lineupIDs = []
for player in lineup:
# finds player's ID
playerDict = players.find_players_by_full_name(player)[0]
lineupIDs.append(playerDict["id"])
# creates dictionary of ids as keys and names as values
playerID_dict = {}
for i in range(len(lineup)):
playerID_dict[lineupIDs[i]] = lineup[i]
# creates list of opposing players ID's in lineup
oppLineupIDs = []
for player in oppLineup:
# finds player's ID
playerDict = players.find_players_by_full_name(player)[0]
oppLineupIDs.append(playerDict["id"])
# creates dictionary of ids as keys and names as values
oppPlayerID_dict = {}
for i in range(len(oppLineup)):
oppPlayerID_dict[oppLineupIDs[i]] = oppLineup[i]
def stats():
playerId = players.find_players_by_full_name(
request.args.get('player'))[0].get('id', None)
player_info = json.loads(
commonplayerinfo.CommonPlayerInfo(
player_id=playerId).get_normalized_json()).get(
'CommonPlayerInfo', None)[0]
player_headline_stats = json.loads(
commonplayerinfo.CommonPlayerInfo(
player_id=playerId).get_normalized_json()).get(
'PlayerHeadlineStats', None)[0]
player_stats = json.loads(
playerprofilev2.PlayerProfileV2(
per_mode36="PerGame", player_id=playerId).get_normalized_json())
teamId = player_info.get('TEAM_ID', None)
profile_picture = "https://ak-static.cms.nba.com/wp-content/uploads/headshots/nba/%s/2019/260x190/%s.png" % (
teamId, playerId)
return {
**player_info,
**player_headline_stats,
**player_stats, "profile_picture": profile_picture
}
def main(season):
#All NBA Players Information in DataFrame
nba_players_info = pd.concat([pd.DataFrame.from_dict(players.get_players()[i], orient='index').transpose() for i in range(len(players.get_players()))],ignore_index=True)
#All NBA Teams Information in DataFrame
nba_teams_info = pd.concat([pd.DataFrame.from_dict(teams.get_teams()[i], orient='index').transpose() for i in range(30)],ignore_index=True)
#Players that are active right now
players_active = nba_players_info[nba_players_info['is_active'] == True].reset_index(drop=True)
#Players Active in Array
players_active_array = players_active['full_name'].values
#Teams in Array
teams_array = nba_teams_info['full_name'].values
#Seasons in Array
seasons = ['2018-19','2017-18','2016-17','2015-16','2014-15','2013-14','2012-13','2011-12','2010-11','2009-10']
#Stephs ID
steph_id = players.find_players_by_full_name('Steph')[1]['id']
input_season_df = season_player(season, steph_id, players_active)
input_season_df.to_csv("Steph_" + season + "_matchup.csv")
def find_players(request):
if request.method == 'GET':
term = request.GET['term']
foundPlayers = json.dumps(players.find_players_by_full_name(term))
return HttpResponse(foundPlayers) # Sending a success response
else:
return HttpResponse("Request method is not a GET")
def getSeasonTotalForPlayer(name, season):
Id = players.find_players_by_full_name(name)[0]["id"]
career = playercareerstats.PlayerCareerStats(player_id=Id)
seasonTotalsDf = career.season_totals_regular_season.get_data_frame()
seasonStatsDf = seasonTotalsDf.loc[seasonTotalsDf["SEASON_ID"] == season]
#add name for convience
seasonStatsDf.insert(0, 'Name', name)
return seasonStatsDf
def find_players(player_name):
found_players = {}
if player_name.isdigit():
found_players = [players.find_player_by_id(player_name)]
else:
found_players = players.find_players_by_full_name(player_name)
return found_players
def get_player_id(name):
p = players.find_players_by_full_name(name)
if len(p) == 0:
raise ValueError('No name matching regex pattern: {}'.format(name))
elif len(p) > 1:
raise ValueError(
'Multiple players matching regex pattern: {}'.format(name))
print 'Found player: {}'.format(p[0]['full_name'])
return p[0]['full_name'], p[0]['id']
def get_player_info(name):
player_in = players.find_players_by_full_name(name)
player_stats = commonplayerinfo.CommonPlayerInfo(player_in[0]['id']).player_headline_stats
players_list.append('Name: ' + player_in[0]['full_name'])
players_list.append('Year: ' + player_stats.get_dict()['data'][0][2]
+ ', PPG: ' + str(player_stats.get_dict()['data'][0][3])
+ ', APG: ' + str(player_stats.get_dict()['data'][0][4]) +
', RPG: ' + str(player_stats.get_dict()['data'][0][5])
+ ', PIE: ' + str(player_stats.get_dict()['data'][0][6])
)
def getData(self, player: str, fileType: Output):
playerData = players.find_players_by_full_name(player)
shotCharts = {}
for player in playerData:
shotCharts[
player['full_name']] = playerdashptshots.PlayerDashPtShots(
team_id=0, player_id=player['id'])
return self.FileMappings[fileType](shotCharts)
def search_for_player(p_name):
try:
player = players.find_players_by_full_name(p_name)[0]
id = player['id']
info = fantasywidget.FantasyWidget(player_id_nullable=id)
p_data = info.fantasy_widget_result.get_dict()['data']
if not p_data:
raise Exception("player probably not active")
return p_data
except:
raise Exception("couldn't find the player")
def getShotData(name, year):
global string_season
string_season = f"{str(year)}-{str(year+1)[-2:]}"
#string_season = 2017-19
playerID = players.find_players_by_full_name(name)[0]['id']
shotchart_detail = ShotChartDetail(team_id=0,
player_id=playerID,
season_nullable=string_season,
context_measure_simple="FGA")
shotData = shotchart_detail.get_data_frames()[0]
shotData["LOC_X"] *= -1
return shotData
def submitLineup(self):
# gets user's lineup and puts players into list
pg = self.entryPG.get()
sg = self.entrySG.get()
sf = self.entrySF.get()
pf = self.entryPF.get()
c = self.entryC.get()
g = self.entryG.get()
f = self.entryF.get()
util1 = self.entryUtil1.get()
util2 = self.entryUtil2.get()
util3 = self.entryUtil3.get()
lineup = [pg, sg, sf, pf, c, g, f, util1, util2, util3]
# creates list of player ID's in lineup
lineupIDs = []
for player in lineup:
# finds player's ID
# try/except in case player name is spelt wrong
try:
playerDict = players.find_players_by_full_name(player)[0]
lineupIDs.append(playerDict["id"])
except:
print(
"Player wasn't found. Please trying spelling it exactly as listed on NBA.com"
)
## need to fix this part to be able to work if a name is spelt wrong
# creates dictionary of ids as keys and names as values
playerID_dict = {}
for i in range(len(lineup)):
playerID_dict[lineupIDs[i]] = lineup[i]
# goes through each player ID
for playerID in playerID_dict.keys():
# uses the PlayerProfileV2 endpoint to get the regular season per game stats for player
playerInfo = playerprofilev2.PlayerProfileV2(per_mode36="PerGame",
player_id=playerID)
# reads the json file into a variable
jsonInfo = json.loads(playerInfo.get_json())
# gets the current and last season stat lines for the player
currentSeason = jsonInfo["resultSets"][0]["rowSet"][-1]
lastSeason = jsonInfo["resultSets"][0]["rowSet"][-2]
print(playerID_dict[playerID])
print("Points:", currentSeason[-1], " Assists:", currentSeason[-6],
" Rebounds:", currentSeason[-7], " Steals:",
currentSeason[-5], " Blocks:", currentSeason[-4],
" Turnovers:", currentSeason[-3])
print()
def getIds(fullName):
# find player id by full name
try:
pd = players.find_players_by_full_name(fullName)
player_id = pd[0]['id']
except Exception:
return "error"
# get the player's current team (seems quite extensive to do
# it like this, but I don't want ppl to have to enter in
# a team name as well just to get a shot chart)
info = commonplayerinfo.CommonPlayerInfo(player_id, headers=headers)
team_id = info.common_player_info.get_data_frame()['TEAM_ID'][0]
# return id's as key-value pair
return {'player_id': player_id, 'team_id': team_id}
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 get_player_name(name):
hits = sorted(players.find_players_by_full_name(name),
key=lambda r: r["id"],
reverse=True)
if len(hits) == 1:
idx = 0
else:
print('Search hits:')
for i, h in enumerate(hits):
print(f"{i}: {h['full_name']} (id: {h['id']})")
sel = input('>>> Select player [0]: ')
idx = int(sel) if sel else 0
print("")
return print_player_info(hits[idx]["id"])
def search():
"""Search post request when searching for a specific player or team.
"""
name = request.form["searchname"]
split_name = name.split(" ", 1)
fullname = name.lower()
if name.upper() == "YAO MING":
return redirect(url_for("players", playerid="2397"))
player = playersapi.find_players_by_full_name(fullname)
try:
getplayerid = player[0]['id']
get_player = True
except:
get_player = False
if get_player:
return redirect(url_for("players", playerid=getplayerid))
else:
return render_template("search.html")
def getPlayerIdsByName(player_name: str, #Only required argument
only_active: bool = False, fuzzy_match: bool = False) \
-> Optional[Dict[int, str]]:
"""
Function that takes a player name and returns a dictionary of matching names indexed by id
NOTE: any optional parameters set to True WILL make the function slower
:param player_name: str to search for
:param only_active: optional param to only return active players
:param fuzzy_match: optional param to use fuzzy matching if more or less than one result is returned
:return:
"""
stripped_name = player_name.strip()
if stripped_name == "":
return None
all_matches = players.find_players_by_full_name(stripped_name)
ret_dict = {}
if all_matches is None or len(all_matches) < 1:
if fuzzy_match:
return fuzzyids.getFuzzyPlayerIdsByName(stripped_name,
only_active=only_active)
else:
return None
elif only_active:
for match in all_matches:
if match.get('is_active'):
ret_dict[match.get('id')] = match.get('full_name')
else:
for match in all_matches:
ret_dict[match.get('id')] = match.get('full_name')
if fuzzy_match and len(ret_dict) > 1:
return fuzzyids.getFuzzyPlayerIdsByName(stripped_name,
only_active=only_active)
else:
return ret_dict
def getShotData2(name, startYear, endYear):
global string_season
global seasonList
global playerName
playerName = name
string_season = f"{str(startYear)}-{str(endYear)[-2:]}"
playerID = players.find_players_by_full_name(name)[0]['id']
shotDataList = []
for year in range(startYear, endYear): #goes to 2019(endYear-1)
currentSeason = f"{str(year)}-{str(year+1)[-2:]}"
seasonList.append(currentSeason)
shotchart_detail = ShotChartDetail(team_id=0,
player_id=playerID,
season_nullable=currentSeason,
context_measure_simple="FGA")
shotData = shotchart_detail.get_data_frames()[0]
shotData["LOC_X"] *= -1
shotDataList.append(shotData)
return shotDataList
def get_shotchart_league_averages(player_name: str,
season: str = CURRENT_SEASON,
team_id: Optional[str] = None):
"""
Retrieves shotchart detailed data and league averages for each specific zones.
:param player_name: Player's full name whose shotchart will be retrieved.
:param team_id: Team id which is used only if multiple players are found
:param season: Season for which the data will be retrieved
:return: Shotchart for player in given season
"""
# Let's assume that players are correctly on first index
players_for_name = players.find_players_by_full_name(player_name)
if not players_for_name:
raise ValueError('Invalid player name given, no players found')
if len(players_for_name) == 1:
player = players_for_name[0]
else:
# todo dbratulic: USE TEAM ID TO FETCH PLAYER_ID
print("Will use " + team_id +
" in future, using first player for now.")
player = players_for_name[0]
shotchart_obj = ShotChartDetail(
team_id=0, # not necessary for fetching shotchart data
player_id=player['id'],
season_nullable=season,
context_measure_simple='FGA')
dataset, league_averages = shotchart_obj.get_data_frames()
dataset.LOC_X = -dataset.LOC_X # REAL DATA IS FLIPPED
dataset = dataset.loc[(dataset.SHOT_ZONE_AREA != "Back Court(BC)")
&
(dataset.LOC_Y < 300
)] # drop shots that aren't close to the center
return dataset, league_averages
def player_average_stats(player_name):
player_search = players.find_players_by_full_name(player_name)
plural = ""
if len(player_search) == 0:
print("No player with name '%s' found." % name)
sys.exit(0)
if len(player_search) > 1:
plural = "s"
print("Found player%s matching the name '%s'!" % (plural, name))
for player in player_search:
player_id = player['id']
player_info = commonplayerinfo.CommonPlayerInfo(
player_id=player_id).get_normalized_dict()
# Display the players' information
#print("----General Information----")
#for info_key, info_value in player_info['CommonPlayerInfo'][0].items():
# print(info_key + ": " + str(info_value))
for stats_key, stats_value in player_info["PlayerHeadlineStats"][
0].items():
if stats_key in ["PLAYER_ID", "PLAYER_NAME"]:
continue
print(stats_key + ": " + str(stats_value))
def get_player_stats(first_name: str, last_name: str) -> Dict:
"""
Returns the stats for a player in standard format
:param first_name:
:param last_name:
:return:
"""
players = PlayerHelper.find_players_by_full_name(
"{first_name} {last_name}".format(first_name=first_name,
last_name=last_name))
if len(players) > 1:
logger.error(
"Multiple players found with the name - {first_name} {last_name}".
format(first_name=first_name, last_name=last_name))
raise MultiplePlayersFoundException
if len(players) == 0:
logger.error(
"Could not find a player with the name - {first_name} {last_name}".
format(first_name=first_name, last_name=last_name))
raise PlayerNotFoundException
player_id = players[0]['id']
logger.info(
"Fetching the player id for {first_name}, {last_name} - {player_id}".
format(first_name=first_name, last_name=last_name,
player_id=player_id))
all_player_stats = PlayerCareerStats(
player_id, PerModeSimple.per_game).get_normalized_dict()
yoy_stats = all_player_stats['SeasonTotalsRegularSeason']
player_stats = _format_results(yoy_stats)
return player_stats
def GetNBAId(playerFullName):
playerObj=players.find_players_by_full_name(playerFullName)
return playerObj[0]["id"]
def nameToId(player_name):
return players.find_players_by_full_name(player_name)[0].get('id')
def populate_chart(player, season, maptype, filter_paint_shots, width=2):
### Create the halfcourt ###
fig, ax = plt.subplots(1, figsize=(10, 10))
hoop = plt.Circle((0, 0),
radius=7.5,
linewidth=width,
color='black',
fill=False)
backboard = Rectangle((-30, -7.5),
60,
-1,
linewidth=width,
color='black',
fill=False)
paint = Rectangle((-60, -47.5),
120,
190,
linewidth=width,
color='black',
fill=False)
outer_rectangle = Rectangle((-80, -47.5),
160,
190,
linewidth=width,
color='black',
fill=False)
ft_arc = Arc((0, 142.5),
120,
120,
theta1=0,
theta2=180,
linewidth=width,
color='black',
fill=False)
ft_arc_bottom = Arc((0, 142.5),
120,
120,
theta1=180,
theta2=0,
linewidth=width,
color='black',
linestyle="dashed",
fill=False)
corner_3_left = Rectangle((220, -47.5),
-1,
140,
linewidth=width,
color='black',
fill=False)
corner_3_right = Rectangle((-220, -47.5),
-1,
140,
linewidth=width,
color='black',
fill=False)
three_pt_arc = Arc((0, 88),
440,
280,
theta1=0,
theta2=180,
linewidth=width,
color='black',
fill=False)
out_of_bounds = Rectangle((-250, -47.5),
500,
470,
linewidth=width,
color='black',
fill=False)
court_elements = [
hoop, backboard, paint, outer_rectangle, ft_arc, ft_arc_bottom,
corner_3_left, corner_3_right, three_pt_arc, out_of_bounds
]
for element in court_elements:
ax.add_patch(element)
### Populate the court with the specific players data ###
player = player.lower()
playerID = players.find_players_by_full_name(player)[0]["id"]
url = "https://stats.nba.com/stats/shotchartdetail?Period=0&VsConference=&LeagueID=00&LastNGames=0&TeamID=0&PlayerPosition=&Location=&Outcome=&ContextMeasure=FGA&DateFrom=&StartPeriod=&DateTo=&OpponentTeamID=0&ContextFilter=&RangeType=&Season=%s&AheadBehind=&PlayerID=%d&EndRange=&VsDivision=&PointDiff=&RookieYear=&GameSegment=&Month=0&ClutchTime=&StartRange=&EndPeriod=&SeasonType=Regular+Season&SeasonSegment=&GameID=" % (
season, playerID)
# Get request headers User Agent
headers = {
'User-Agent':
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.142 Safari/537.36'
}
response = requests.get(url, headers=headers)
# Grab the headers to be used as column headers for our DataFrame
column_headers = response.json()['resultSets'][0]['headers']
# Grab the shot chart data
shots = response.json()['resultSets'][0]['rowSet']
shot_df = pd.DataFrame(data=shots, columns=column_headers)
if maptype == "heatmap":
if filter_paint_shots == "no":
sns.kdeplot(-1 * shot_df.LOC_X,
shot_df.LOC_Y,
shade="True",
color="red",
n_levels=1000)
else:
paint_shots = shot_df[shot_df.SHOT_ZONE_RANGE != "Less Than 8 ft."]
sns.kdeplot(-1 * paint_shots.LOC_X,
paint_shots.LOC_Y,
shade="True",
color="red",
n_levels=1000)
else:
plt.scatter((-1 * shot_df.LOC_X), shot_df.LOC_Y)
### Set graph limits and convert to png ###
ax.set_xlim(-300, 300)
ax.set_ylim(-100, 500)
plt.axis("off")
img = io.BytesIO()
plt.savefig(img, format="png")
img.seek(0)
graph_url = base64.b64encode(img.getvalue()).decode()
plt.close()
bball_court = 'data:image/png;base64,{}'.format(graph_url)
return bball_court
# # # json = nba_api.stats.endpoints.ShotChartDetail(nba_api.stats.static.teams.find_teams_by_city("Boston"),)
# # # print(json)
# #
# labels = ['GRID_TYPE','GAME_ID','GAME_EVENT_ID',"PLAYER_ID","TEAM_ID",'SHOT_ATTEMPTED_FLAG','SHOT_MADE_FLAG']
# x = x.get_data_frames()[0]
# x = x.drop(columns = labels)
# x = x[(x.MINUTES_REMAINING < 3) & (x.PERIOD == 4)]
# print(x)
# # print(y)
# # print(y.EVENT_TYPE.unique())
# # y.describe
# nbashots.shot_chart(x.LOC_X,x.LOC_Y,kind="scatter",color="y",court_color='b')
# plt.show()
# print(x)
jharden = players.find_players_by_full_name("James Harden")[0]
x = hustlestatsboxscore.HustleStatsBoxScore('0041900221').get_data_frames()[1]
columns = [
'GAME_ID', "TEAM_ID", "TEAM_ABBREVIATION", "TEAM_CITY", "PLAYER_ID",
"START_POSITION", "COMMENT", "MINUTES"
]
labels = [
'PLAYER_NAME', "PTS", "CONTESTED_SHOTS", "CONTESTED_SHOTS_2PT",
"CONTESTED_SHOTS_3PT", "DEFLECTIONS", "CHARGES_DRAWN", "SCREEN_ASSISTS",
"SCREEN_AST_PTS", "OFF_LOOSE_BALLS_RECOVERED", "DEF_LOOSE_BALLS_RECOVERED",
"LOOSE_BALLS_RECOVERED", "OFF_BOXOUTS", "DEF_BOXOUTS",
"BOX_OUT_PLAYER_TEAM_REBS", "BOX_OUT_PLAYER_REBS", "BOX_OUTS"
]
# y = x.drop(columns = columns)
y = x[labels].sort_values(by=['CONTESTED_SHOTS'])
# format data for dataframe
df = pandas.DataFrame(result_sorted)
df.columns = ["Percent Change in Opp. RA FGA", "Player"]
cols = df.columns.tolist()
cols = cols[::-1]
df = df[cols]
print(df)
# format data for html table
print(
"<table><tr><td>Player</td><td>Percent Change in <br />Opp. RA FGA</td></tr>"
)
for entry in result_sorted:
print("\n<tr><td>" + entry[1] + "</td><td>" + str(entry[0]) + "</td></tr>")
print("\n</table>")
# correlation with height
# api calls
results_with_height = []
for entry in result_sorted:
playerid = players.find_players_by_full_name(entry[1])[0]['id']
height = commonplayerinfo.CommonPlayerInfo(
player_id=playerid).common_player_info.data['data'][0][10]
height_inches = height.split("-")[0] * 12 + height.split("-")[
1] #convert to inches
results_with_height.append((entry[1], entry[0], height_inches))
#correlation
df = pandas.DataFrame(results_with_height)
df.corr()
print(df.corr())
from nba_api.stats.endpoints import commonplayerinfo
from nba_api.stats.endpoints import playerdashboardbylastngames
from nba_api.stats.static import players
player_info = commonplayerinfo.CommonPlayerInfo(2544, "00")
lebron_dict = player_info.common_player_info.get_dict()
# lebron_log = playergamelog.PlayerGameLog(2544, 2017-18, "Regular Season")
# print(lebron_log)
lebron_last_5_games = playerdashboardbylastngames.PlayerDashboardByLastNGames(2544, 0, "Base", 0, 0, "N", "PerGame", 0, "N", "N", "2017-18", "Regular Season")
#lebron_last_5_games_2 = playerdashboardbylastngames.PlayerDashboardByLastNGames(2544, 0, "Base", 0, 0, "N", "PerGame", 0, "N", "N", "2017-18", "Regular Season", "03-20-2018", "03-10-2018")
lebron_5_game_dict = lebron_last_5_games.last5_player_dashboard.get_dict()
#lebron_5_game_dict_2 = lebron_last_5_games_2.last5_player_dashboard.get_dict()
print("Player:" + lebron_dict.get('data')[0][3] + ", Number: " + lebron_dict.get('data')[0][13] + "\n")
print(lebron_5_game_dict.get('data')[0][28])
print(players.find_players_by_full_name('LeBron James')[0].get('id'))
#print(lebron_5_game_dict_2.get('data')[0][28])
#print(lebron_5_game_dict_2)
def playerID(fullName):
# find player by full name
playerDict = players.find_players_by_full_name(fullName)
return playerDict[0]['id']
def margin(player):
criteria = {
'+110': 5,
'+100': 4,
'-100': 3.5,
'-105': 3.25,
'-110': 3,
'-115': 2.5,
'-120': 2,
'-125': 1.5,
'-130': 1,
'-135': 0.75,
'-140': 0.5
} # Subject to change depending on ML implementation
playerID = players.find_players_by_full_name(
player[1])[0]['id'] #find player reference number in static
teamID = endpoints.CommonPlayerInfo(
playerID).get_normalized_dict()['CommonPlayerInfo'][0]['TEAM_ID']
game = endpoints.PlayerNextNGames(
player_id=playerID).get_normalized_dict()['NextNGames'][0]
if game['HOME_TEAM_ID'] == teamID:
opponentID = game['VISITOR_TEAM_ID']
#print(game['VISITOR_TEAM_NAME'], game)
else:
opponentID = game['HOME_TEAM_ID']
#print(game['HOME_TEAM_NAME'], game)
#print(endpoints.Scoreboard().get_normalized_dict())
#print(endpoints.TeamDashboardByClutch(team_id=teamID, opponent_team_id=opponentID).get_normalized_dict()['OverallTeamDashboard'])
#print(endpoints.TeamDashboardByTeamPerformance(team_id=teamID, opponent_team_id=opponentID).get_normalized_dict()['PontsAgainstTeamDashboard'])
#Only accounting for ppg. change variable type in each
last5 = endpoints.PlayerDashboardByLastNGames(
player_id=playerID).get_normalized_dict()['Last5PlayerDashboard'][0][
'PTS'] / endpoints.PlayerDashboardByLastNGames(
player_id=playerID).get_normalized_dict(
)['Last5PlayerDashboard'][0]['GP']
last10 = endpoints.PlayerDashboardByLastNGames(
player_id=playerID).get_normalized_dict()['Last10PlayerDashboard'][0][
'PTS'] / endpoints.PlayerDashboardByLastNGames(
player_id=playerID).get_normalized_dict(
)['Last10PlayerDashboard'][0][
'GP'] #last 10 games (playerdashboardbylastngames)
regSeasonAve = endpoints.PlayerDashboardByLastNGames(
player_id=playerID).get_normalized_dict()['OverallPlayerDashboard'][0][
'PTS'] / endpoints.PlayerDashboardByLastNGames(
player_id=playerID
).get_normalized_dict()['OverallPlayerDashboard'][0][
'GP'] #regular season average (playerdashboardbylastngames)
try:
aveAgainstTeam = \
endpoints.PlayerDashboardByOpponent(player_id=playerID, opponent_team_id=opponentID).get_normalized_dict()[
'OverallPlayerDashboard'][0]['PTS'] / \
endpoints.PlayerDashboardByOpponent(player_id=playerID, opponent_team_id=opponentID).get_normalized_dict()[
'OverallPlayerDashboard'][0]['GP'] # prop_type average against opposing team (playerdashboardbyopponent)
#player[6] = (last5*.3 + last10*0.1 + regSeasonAve*.3 + aveAgainstTeam*.3)
player[6] = (last5 + last10 + regSeasonAve + aveAgainstTeam) / 4
print("last 5: ", last5, " last 10: ", last10, " Reg Season: ",
regSeasonAve, " Against Team: ", aveAgainstTeam, '\n')
except:
player[6] = (last5 + last10 + regSeasonAve) / 3
print("last 5: ", last5, " last 10: ", last10, " Reg Season: ",
regSeasonAve)
#playoff_ave = 0 #if applicable (PlayerCareerStats['CareerTotalsPostSeason'])
#
player[7] = abs(float(player[6]) -
float(player[3])) # + = over margin, - = under margin
#for both over & under
#if player[4] and player[5] in criteria:
if float(player[3]) < float(player[6]): #If an over
player = np.append(player, ['over'])
if 0 <= float(player[7]) <= .5:
player = np.append(player, ['Confidence: 0 (0 - .5)'])
elif .5 <= float(player[7]) <= 1:
if -140 <= float(player[4]) <= -130:
player = np.append(player, ['Confidence: 1 (.5 - 1)'])
elif -130 <= float(player[4]):
player = np.append(player, ['Confidence: 2 (1 - 2.5)'])
else:
player = np.append(player, ['Confidence: 0 (0 - .5)'])
elif 1 <= float(player[7]) <= 2.5:
if -130 <= float(player[4]) <= -115:
player = np.append(player, ['Confidence: 2 (1 - 2.5)'])
elif -115 <= float(player[4]):
player = np.append(player, ['Confidence: 3 (2.5+)'])
else:
player = np.append(player, ['Confidence: 1 (.5 - 1)'])
elif 2.5 <= float(player[7]):
if -115 <= float(player[4]):
player = np.append(player, ['Confidence: 2 (1 - 2.5)'])
else:
player = np.append(player, ['Confidence: 3 (2.5+)'])
else:
player = np.append(player, ['under'])
if 0 <= float(player[7]) <= .5:
player = np.append(player, ['Confidence: 0 (0 - .5)'])
elif .5 <= float(player[7]) <= 1:
if -140 <= float(player[5]) <= -130:
player = np.append(player, ['Confidence: 1 (.5 - 1)'])
elif -130 <= float(player[5]):
player = np.append(player, ['Confidence: 2 (1 - 2.5)'])
else:
player = np.append(player, ['Confidence: 0 (0 - .5)'])
elif 1 <= float(player[7]) <= 2.5:
if -130 <= float(player[5]) <= -115:
player = np.append(player, ['Confidence: 2 (1 - 2.5)'])
elif -115 <= float(player[5]):
player = np.append(player, ['Confidence: 3 (2.5+)'])
else:
player = np.append(player, ['Confidence: 1 (.5 - 1)'])
elif 2.5 <= float(player[7]):
if -115 <= float(player[5]):
player = np.append(player, ['Confidence: 2 (1 - 2.5)'])
else:
player = np.append(player, ['Confidence: 3 (2.5+)'])
print(player)
return 0
