def main():
nba_players = players.get_active_players()
s = connect_spreadsheet()
if nba_players is not None:
print("Assigning Player")
number_assingment(nba_players)
print("Selecting Player")
select(nba_players)
print("Getting Player info")
getPlayerInfo(selected_player)
#Place data in the form
setValuesInGoogle(parse_selected, s)
def update_gamelogs(conn, proxies, seasons, hist=False):
player_gamelog_dfs = []
print(hist)
if hist:
# Fetch players who were active during 2012-2020
player_ids = get_recent_players(conn)
else:
# Fetch all currently active players
player_ids = [player['id'] for player in players.get_active_players()]
player_gamelog_dfs = [
get_player_gamelogs(player_id=player_id,
season=season,
proxies=proxies) for player_id in player_ids
for season in seasons
]
player_gamelog_df = pd.concat(player_gamelog_dfs)
# Convert GAME_DATE col to datetime
player_gamelog_df.GAME_DATE = pd.to_datetime(player_gamelog_df.GAME_DATE)
# NEW COLUMN: games in last 7 days
player_gamelog_df = last_7_days(player_gamelog_df, 'GAME_DATE')
if hist:
player_gamelog_df.to_sql('Player_Gamelogs',
conn,
index=False,
if_exists='replace')
else:
# Create temp table to store current season gamelogs
# Insert temp table into main table, ignoring duplicates
player_gamelog_df.to_sql('temp',
conn,
index=False,
if_exists='replace')
cur = conn.cursor()
sql = '''INSERT INTO Player_Gamelogs
SELECT *
FROM temp t
WHERE NOT EXISTS (
SELECT 1
FROM Player_Gamelogs p
WHERE p.Player_ID = t.Player_ID
AND p.Game_ID = t.Game_ID)'''
cur.execute(sql)
conn.commit()
def update_player_list():
"""
Create or update JSON file (player_names) with active player names and inactive player names
"""
# Get active player and inactive player info from nba_api
active_player_info = get_active_players()
inactive_player_info = get_inactive_players()
# Filter through player info and retrieve only the names as a list
active_players = {info['full_name']: info['id'] for info in active_player_info}
inactive_players = {info['full_name']: info['id'] for info in inactive_player_info}
# Create dictionary of active and inactive players
all_players = {'active_players': active_players, 'inactive_players': inactive_players}
# Write player names as JSON data to file
with open('player_names.json', 'w+') as f:
f.write(dumps(all_players))
def insert_players():
conn = None
player_list = players.get_active_players()
try:
params = config()
conn = psycopg2.connect(**params)
cur = conn.cursor()
cur.executemany("""INSERT INTO players VALUES
(%(id)s, %(full_name)s, %(first_name)s, %(last_name)s, %(is_active)s)""",
player_list)
conn.commit()
cur.close()
print('Finished inserting data')
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
def get_nba_id():
nba_players = players.get_active_players()
playerdf = pd.DataFrame()
for player in nba_players:
career_stats = playercareerstats.PlayerCareerStats(
player_id=player['id'])
career_df = career_stats.get_data_frames()[0]
grouped = career_df.groupby(["PLAYER_ID"]).sum(numeric_only=True)
grouped['FG_PCT'] = career_df['FG_PCT'].mean() * 100
grouped['FG3_PCT'] = career_df['FG3_PCT'].mean() * 100
grouped['FT_PCT'] = career_df['FT_PCT'].mean() * 100
playerdf = pd.concat([playerdf, grouped], sort=False)
time.sleep(.600)
print(playerdf)
playerdf.to_csv("NBA_PLAYERS_CAREER_STATS.csv")
from nba_api.stats.static import players, teams
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()
from nba_api.stats.static import players as p from nba_api.stats.endpoints import playercareerstats as pcs import pandas as pd # useful for id, first_name, last_name players_df = pd.DataFrame(p.get_active_players()) # players_df[['id', 'first_name', 'last_name']] # player = pcs.PlayerCareerStats(player_id = 2544) # put ids into PlayerCareerStats checkker to grab career stats of all # use BoxScoreTraditional library to start with for good base stats; use above 2 comments for help to start
def get_active_players():
allplayers = playersapi.get_active_players()
players_list = []
for player in allplayers:
players_list.append(player['full_name'])
return players_list
from nba_api.stats.endpoints import *
from nba_api.stats.library import data
from nba_api.stats.library import parameters
from nba_api.stats.static import players
from FRules import *
from FPointsCalc import *
import csv
import time
# create a list of active players
act_plyr = players.get_active_players()
rules = FRules
fpoints_1819 = {}
fpoints_1718 = {}
fpoints_diff = {}
PLAYERS = []
for plyr_dict in act_plyr:
overall_player_dash = playerdashboardbylastngames.PlayerDashboardByLastNGames(
**{
'player_id': plyr_dict['id'],
'season': '2018-19',
'per_mode_detailed': parameters.PerModeDetailed.per_game
}).get_normalized_dict()['OverallPlayerDashboard']
if len(overall_player_dash) == 1:
games_played = overall_player_dash[0]['GP']
minutes_per_game = overall_player_dash[0]['MIN']
if (games_played > 30 and minutes_per_game > 5):
PLAYERS.append(plyr_dict)
print(plyr_dict['full_name'])
from nba_api.stats.endpoints import *
from nba_api.stats.static import players
from nba_api_helpers import try_request
try:
active_players = players.get_active_players()
for player in active_players:
if player['full_name'] == 'Stephen Curry':
while True:
dummy = try_request(
commonplayerinfo.CommonPlayerInfo(player['id']))
print('eggs')
except:
print('got it')
import requests
import json
import random
import wikipedia
import atexit
from time import sleep
from nba_api.stats.static import players
from nba_api.stats.endpoints import commonplayerinfo, playergamelog
# Get raw player data
player_info_raw = players.get_active_players()
# Store sanitized player data
player_info = []
with open('data.json') as f:
player_info = json.load(f)
# Searches Qwant for an image and returns a url
def img_search(query):
r = requests.get("https://api.qwant.com/api/search/images",
params={
'count': 1,
'q': query,
't': 'images',
'safesearch': 1,
'locale': 'en_US',
'uiv': 1
},
headers={
'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:69.0) Gecko/20100101 Firefox/69.0',
import dictionary as dict
import json
from basketball_reference_scraper.players import get_stats
from nba_api.stats.static import players
from queries import insert_players
from pandas import ExcelWriter
player_names = []
player_career_stats = []
player_details = players.get_active_players()
writer = ExcelWriter('PlayerStats.xlsx')
for full_name in player_details:
player_names.append(full_name["full_name"])
#
# for player in player_names:
# print(player)
# stats = get_stats(player, 'PER_GAME', False, True)
# print(stats)
print(players.get_active_players())
insert_players()
#
# writer.save()
def get_league_players(self):
"""
Creates a list of all active players, using data from the nba_api
Returns:
league_players (List<Player>): a list of all players in the league
"""
self.player_list = []
self.player_name_list = []
# Find nba_api player IDs for each player in the league (these IDs are different than yahoo fantasy IDs)
for player in nba_api_players.get_active_players():
self.player_name_list.append([
player["full_name"],
nba_api_players.find_players_by_full_name(
player["full_name"])[0]["id"]
])
for player in self.player_name_list:
# Look up fantasy profile for player
# nba_api calls can be unrealiable, so use exceptions to prevent code from crashing if a query fails
try:
self.player_profile = nba_api_endpoints.playerfantasyprofile.PlayerFantasyProfile(
player[1])
except Exception:
continue
# Only add players who have at least played one game
if (len(self.player_profile.get_dict()["resultSets"][0]["rowSet"])
!= 0):
# Find player's nba team
try:
self.nba_team = nba_api_endpoints.playerprofilev2.PlayerProfileV2(
player[1]).get_dict()["resultSets"][0]["rowSet"][-1][4]
except Exception:
continue
# Create stat dictionary for player
self.player_stat_list = self.player_profile.get_dict(
)["resultSets"][0]["rowSet"][0]
self.player_stat_dict = {
"GP":
float(self.player_stat_list[2]),
"FG%":
float(self.player_stat_list[9]),
"FT%":
float(self.player_stat_list[15]),
"3PTM":
float(self.player_stat_list[10]) /
float(self.player_stat_list[2]),
"PTS":
float(self.player_stat_list[26]) /
float(self.player_stat_list[2]),
"REB":
float(self.player_stat_list[18]) /
float(self.player_stat_list[2]),
"AST":
float(self.player_stat_list[19]) /
float(self.player_stat_list[2]),
"TO":
float(self.player_stat_list[20]) /
float(self.player_stat_list[2]),
"ST":
float(self.player_stat_list[21]) /
float(self.player_stat_list[2]),
"BLK":
float(self.player_stat_list[22]) /
float(self.player_stat_list[2]),
"DD":
float(self.player_stat_list[28]) /
float(self.player_stat_list[2]),
"TD":
float(self.player_stat_list[29]) /
float(self.player_stat_list[2])
}
# Infer if the player is injured by checking their most recent game, to avoid suggestions who are on the IR
try:
self.recent_game = nba_api_endpoints.playergamelog.PlayerGameLog(
player[1]).get_dict()["resultSets"][0]["rowSet"][0][3]
if (datetime.strptime(self.recent_game, "%b %d, %Y") +
timedelta(days=7)) < datetime.now():
self.is_injured = True
else:
self.is_injured = False
except Exception:
self.is_injured = False
pass
# Initiate player object to add into league player list
self.player_list.append(
Player(player[0], None, self.nba_team, None, None,
self.player_stat_dict, self.is_injured))
return (self.player_list)
109140000))
st.subheader(
'The NBA Salary Cap for 2020-21 is $109.140M. The Luxury Tax Level is $132.627M.'
)
elif page == 'NBA Contracts':
st.title("League Wide Salary and Contract Details")
st.header(
"Please choose a player to view contract details or explore list")
st.subheader("* Player Option")
st.subheader('** Team Option')
st.write('')
st.subheader(
"Choose a Player to View Their Contract or Scroll Down to View all NBA contracts"
)
active_player_dict = players.get_active_players()
active_league = players.get_active_players()
for player in active_league:
player_active_information = [l['full_name'] for l in active_league]
player_active_information.insert(0, "Select or Type a Player")
name = st.selectbox(' ', (player_active_information))
names = []
with open('nbaplayersalaries.csv', 'r') as read_obj:
csv_reader = reader(read_obj)
for row in csv_reader:
from nba_api.stats.endpoints import playergamelog
from nba_api.stats.endpoints import boxscorematchups
from nba_api.stats.endpoints import leaguegamelog
from nba_api.stats.endpoints import playercareerstats
from nba_api.stats.static import players
import json
import time
import os
import ast
from sklearn.cluster import KMeans
from sklearn.mixture import GaussianMixture
import numpy as np
from flask import Flask, request, jsonify
active_players = players.get_inactive_players() + players.get_active_players()
# active_players = players.get_active_players()
def generatePlayerCarrerStat():
f = open("stattt.txt", "a")
for player in active_players:
id = player['id']
time.sleep(0.5)
player_info = playercareerstats.PlayerCareerStats(player_id=id,
timeout=1000)
player_reg_stat = player_info.career_totals_regular_season.get_dict()
player_stat = {
"player": player,
"reg_season_career_total": player_reg_stat
}
def get_players(active_only=False):
if active_only:
return players.get_active_players()
return players.get_players()