def get_player_instance():
global SPORT, PLAYER_ID, PLAYERS, DOWNLOADED_PLAYERS
player_instance = create_nba_staging_instances(
player_config['instance_template'],
player_config['rename_dict'],
sport=SPORT,
player_id=PLAYER_ID,
endpoint='player',
proxies=Proxies)
PLAYERS.append(player_instance)
DOWNLOADED_PLAYERS |= {(PLAYER_ID, )}
return player_instance
def get_pbp_instance():
global SEASON, SPORT, GAME_ID, PBPS, DOWNLOADED_PBP
pbp_instance = create_nba_staging_instances(
pbp_config['instance_template'],
pbp_config['rename_dict'],
season=SEASON,
sport=SPORT,
game_id=GAME_ID,
endpoint='pbp',
proxies=Proxies)
PBPS.append(pbp_instance)
DOWNLOADED_PBP |= {(GAME_ID, )}
return pbp_instance
def get_roster_instance():
global SEASON, SPORT, TEAM_ID, ROSTERS, DOWNLOADED_ROSTERS
roster_instance = create_nba_staging_instances(
roster_config['instance_template'],
roster_config['rename_dict'],
season=SEASON,
sport=SPORT,
team_id=TEAM_ID,
endpoint='roster',
proxies=Proxies)
ROSTERS.append(roster_instance)
DOWNLOADED_ROSTERS |= {(SPORT, SEASON, TEAM_ID)}
return roster_instance
def get_game_box_instance():
global SEASON, SPORT, GAME_ID, GAME_BOXES, DOWNLOADED_GAME_BOXES
game_box_instance = create_nba_staging_instances(
boxscores_config['instance_template'],
boxscores_config['rename_dict'],
season=SEASON,
sport=SPORT,
game_id=GAME_ID,
endpoint='box_score',
proxies=Proxies)
GAME_BOXES.append(game_box_instance)
DOWNLOADED_GAME_BOXES |= {(GAME_ID, )}
return game_box_instance
def get_game_summary_instance():
global SEASON, SPORT, GAME_ID, GAME_SUMMARIES, DOWNLOADED_GAME_SUMMARY
game_summary_instance = create_nba_staging_instances(
game_summary_config['instance_template'],
game_summary_config['rename_dict'],
season=SEASON,
sport=SPORT,
game_id=GAME_ID,
endpoint='game_summary',
proxies=Proxies)
GAME_SUMMARIES.append(game_summary_instance)
DOWNLOADED_GAME_SUMMARY |= {(GAME_ID, )}
return game_summary_instance
def get_win_prob_instance():
global SEASON, SPORT, GAME_ID, WIN_PROBS, DOWNLOADED_WIN_PROB
win_prob_instance = create_nba_staging_instances(
win_prob_config['instance_template'],
win_prob_config['rename_dict'],
season=SEASON,
sport=SPORT,
endpoint='win_prob',
game_id=GAME_ID,
proxies=Proxies)
WIN_PROBS.append(win_prob_instance)
DOWNLOADED_WIN_PROB |= {(GAME_ID, )}
return win_prob_instance
def get_schedule_instance():
global SEASON, SPORT, GAME_DATE, SCHEDULES, DOWNLOADED_DATES
schedule_instance = create_nba_staging_instances(
schedule_config['instance_template'],
schedule_config['rename_dict'],
season=SEASON,
sport=SPORT,
date=GAME_DATE,
endpoint='schedule',
proxies=Proxies)
SCHEDULES.append(schedule_instance)
DOWNLOADED_DATES |= {(GAME_DATE, )}
return schedule_instance
def get_period_starter_instance(pbp_instance):
global SEASON, SPORT, GAME_ID, PERIOD, STARTERS
minutes_in_period = period_min[pbp_instance['sport']]
minutes_in_ot = ot_min[pbp_instance['sport']]
period_starters = set()
dict_col_names = pbp_instance['json']['resultSets'][0]['headers']
for play in pbp_instance['json']['resultSets'][0]['rowSet']:
play_details = dict(zip(dict_col_names, play))
PERIOD = play_details['PERIOD']
pc_time = play_details['PCTIMESTRING']
if play_details['EVENTMSGTYPE'] not in [10, 12, 13]:
if PERIOD not in period_starters:
minutes, seconds = pc_time.split(':')
sec_remaining = (int(minutes) * 60 + int(seconds))
if PERIOD < 5:
start_range = ((PERIOD - 1) * minutes_in_period * 60) * 10
end_range = (start_range +
(minutes_in_period * 60 - sec_remaining) * 10)
else:
start_range = (4 * minutes_in_period * 60 +
(PERIOD - 4) * minutes_in_ot * 60) * 10
end_range = (start_range +
(minutes_in_ot * 60 - sec_remaining) * 10)
starter_instance = create_nba_staging_instances(
period_starters_config['instance_template'],
period_starters_config['rename_dict'],
season=SEASON,
sport=SPORT,
game_id=GAME_ID,
period=PERIOD,
start_range=start_range,
end_range=end_range,
range_type=2,
endpoint='period_starters',
proxies=Proxies)
if starter_instance['json'] is not None:
if len(starter_instance['json']['resultSets'][0]
['rowSet']):
STARTERS.append(starter_instance)
period_starters |= {PERIOD}
return starter_instance
def get_shot_chart_instance():
global SEASON, SPORT, SEASON_TYPE, START_DATE, END_DATE, CONTEXT, PLAYER_ID, \
TEAM_ID, SHOT_CHARTS
shot_chart_instance = create_nba_staging_instances(
shot_chart_config['instance_template'],
shot_chart_config['rename_dict'],
season=SEASON,
sport=SPORT,
season_type=SEASON_TYPE,
start_date=START_DATE,
end_date=END_DATE,
context=CONTEXT,
player_id=PLAYER_ID,
team_id=TEAM_ID,
endpoint='shot_chart',
proxies=Proxies)
SHOT_CHARTS.append(shot_chart_instance)
return shot_chart_instance
def get_season_instance():
global SEASON, SPORT, SEASON_TYPE, SEASONS
if MAX_SEASON_DATE is not None:
date_from = MAX_SEASON_DATE + timedelta(days=1)
else:
date_from = None
date_to = datetime.now().date() + timedelta(days=-1)
season_instance = create_nba_staging_instances(
season_config['instance_template'],
season_config['rename_dict'],
date_from=date_from,
date_to=date_to,
season=SEASON,
sport=SPORT,
season_type=SEASON_TYPE,
endpoint='season',
participant='P',
proxies=Proxies)
SEASONS.append(season_instance)
return season_instance