wsba-hockey 1.1.0__py3-none-any.whl → 1.1.2__py3-none-any.whl

wsba_hockey/api/api/index.py

@@ -0,0 +1,129 @@
+import pandas as pd
+import numpy as np
+import wsba_hockey as wsba
+import requests as rs
+from fastapi import FastAPI
+from datetime import datetime
+import pytz
+
+app = FastAPI()
+
+@app.get("/")
+def read_root():
+    return {"WeakSide Breakout Analysis": "Welcome to the API!"}
+
+@app.get("/nhl/players/{player_id}")
+def player(player_id: int):
+    player = rs.get(f'https://api-web.nhle.com/v1/player/{player_id}/landing').json()
+
+    return player
+
+@app.get("/nhl/schedule/{date}")
+def schedule_info(date: str):
+    data = rs.get(f'https://api-web.nhle.com/v1/schedule/{date}').json()
+    
+    eastern = pytz.timezone('US/Eastern')
+    for game in data['gameWeek'][0]['games']:
+        game['startTimeEST'] = datetime.strptime(game['startTimeUTC'],'%Y-%m-%dT%H:%M:%SZ').replace(tzinfo=pytz.UTC).astimezone(eastern).strftime('%I:%M %p')
+
+    return data
+
+@app.get("/nhl/games/{game_id}")
+def pbp(game_id: int):
+    df = wsba.nhl_apply_xG(wsba.nhl_scrape_game([game_id],remove=[]))
+    
+    skater = {}
+    goalie = {}
+    team_stats = {}
+    other = df.loc[~df['strength_state'].isin(['5v5','5v4','4v5']),'strength_state'].drop_duplicates().to_list()
+    for strength in [['5v5'],['5v4'],['4v5'],
+                     other,
+                     'all']:
+        
+        s = wsba.nhl_calculate_stats(df,'skater',[2,3],strength,True).replace([np.inf, -np.inf], np.nan).fillna('').to_dict(orient='records')
+        g = wsba.nhl_calculate_stats(df,'goalie',[2,3],strength,True).replace([np.inf, -np.inf], np.nan).fillna('').to_dict(orient='records')
+        t = wsba.nhl_calculate_stats(df,'team',[2,3],strength,True).replace([np.inf, -np.inf], np.nan).fillna('').to_dict(orient='records')
+
+        if strength != 'all':
+            if len(strength)>1:
+                add = 'Other'
+            else:
+                add = strength[0]
+        else:
+            add = 'All'
+
+        skater.update({add:s})
+        goalie.update({add:g})
+        team_stats.update({add:t})
+
+    df = df.fillna('')
+
+    team_data = pd.read_csv('https://weakside-breakout.s3.us-east-2.amazonaws.com/info/nhl_teaminfo.csv')[['triCode','seasonId','teamName.default','teamLogo','Primary Color','Secondary Color','WSBA']]
+
+    info = df[['season','season_type','game_id','game_date',
+                'venue','venue_location']].drop_duplicates().to_dict(orient='records')[0]
+    
+    info.update({'notice':'All data and materials are from the National Hockey League.'})
+
+    teams = {}
+    for team in ['away','home']:
+        df = pd.merge(df,team_data,how='left',left_on=[f'{team}_team_abbr','season'],right_on=['triCode','seasonId']).fillna('')
+        mod = '' if team == 'away' else '_y'
+        teams.update({team: df[[f'{team}_team_abbr'
+                                ,f'{team}_coach',
+                                f'teamName.default{mod}',
+                                f'teamLogo{mod}',
+                                f'Primary Color{mod}',
+                                f'Secondary Color{mod}',
+                                f'WSBA{mod}']].rename(columns={f'{team}_team_abbr':'team_abbr',f'{team}_coach':'coach',
+                                                         f'teamName.default{mod}':'team_name',
+                                                         f'teamLogo{mod}':'team_logo',
+                                                         f'Primary Color{mod}':'primary_color',
+                                                         f'Secondary Color{mod}':'secondary_color',
+                                                         f'WSBA{mod}':'WSBA'
+                                                         }).drop_duplicates().to_dict(orient='records')[0]})
+
+    play_col = [
+        'event_num','period','period_type',
+        'seconds_elapsed','period_time','game_time',"strength_state","strength_state_venue","home_team_defending_side",
+        "event_type_code","event_type","description","event_reason",
+        "penalty_type","penalty_duration","penalty_attribution",
+        "event_team_abbr","event_team_venue",
+        'num_on', 'players_on','ids_on','num_off','players_off','ids_off','shift_type',
+        "event_player_1_name","event_player_2_name","event_player_3_name",
+        "event_player_1_id","event_player_2_id","event_player_3_id",
+        "event_player_1_pos","event_player_2_pos","event_player_3_pos",
+        "event_goalie_name","event_goalie_id",
+        "shot_type","zone_code","x","y","x_fixed","y_fixed","x_adj","y_adj",
+        "event_skaters","away_skaters","home_skaters",
+        "event_distance","event_angle","event_length","seconds_since_last",
+        "away_score","home_score", "away_fenwick", "home_fenwick",
+        "away_on_1","away_on_2","away_on_3","away_on_4","away_on_5","away_on_6","away_goalie",
+        "home_on_1","home_on_2","home_on_3","home_on_4","home_on_5","home_on_6","home_goalie",
+        "away_on_1_id","away_on_2_id","away_on_3_id","away_on_4_id","away_on_5_id","away_on_6_id","away_goalie_id",
+        "home_on_1_id","home_on_2_id","home_on_3_id","home_on_4_id","home_on_5_id","home_on_6_id","home_goalie_id",
+        "event_coach",'xG'
+    ]
+    
+    def sanitize(value):
+        if isinstance(value, (np.generic, np.ndarray)):
+            return value.item()
+        return value
+
+    plays = [
+        {k: sanitize(v) for k, v in row.items() if v != ''}
+        for row in df[[col for col in play_col if col in df.columns]].to_dict(orient='records')
+    ]
+
+    plays = [
+        {k: sanitize(v) for k, v in row.items() if v != ''}
+        for row in df[[col for col in play_col if col in df.columns]].to_dict(orient='records')
+    ]
+
+    return {'info': info,
+            'teams': teams,
+            'skater_stats':skater,
+            'goalie_stats':goalie,
+            'team_stats':team_stats,
+            'plays': plays
+        }

wsba_hockey/data_pipelines.py

@@ -1,3 +1,4 @@
+import os
 import numpy as np
 import pandas as pd
 import wsba_main as wsba
@@ -23,15 +24,16 @@ def pbp_db(seasons):
     for season in seasons:
         pbp = pd.read_parquet(f'pbp/parquet/nhl_pbp_{season}.parquet')
         pbp.loc[pbp['event_type'].isin(wsba.events+['penalty'])].to_csv('temp.csv',index=False)
-        pd.read_csv('temp.csv').to_parquet(f'backblaze_pbp/{season}.parquet',index=False)
+        pd.read_csv('temp.csv').to_parquet(f'aws_pbp/{season}.parquet',index=False)
+        os.remove('temp.csv')
 
 def load_pbp(seasons):
     return pd.concat([pd.read_parquet(f'pbp/parquet/nhl_pbp_{season}.parquet') for season in seasons])
 
 def load_pbp_db(seasons):
-    return pd.concat([pd.read_parquet(f'backblaze_pbp/{season}.parquet') for season in seasons])
+    return pd.concat([pd.read_parquet(f'aws_pbp/{season}.parquet') for season in seasons])
 
-def stats(arg,seasons):
+def build_stats(arg,seasons):
     #Stats building
     for group in arg:
         for season in seasons:
@@ -73,9 +75,70 @@ def game_log(arg,seasons):
                     data['Span'] = season_type[0]
                     dfs.append(data)
             stat = pd.concat(dfs)
-            stat.to_csv(f'stats/game_log/wsba_nhl_{season}_game_log.csv',index=False)
-            stats = pd.read_csv(f'stats/game_log/wsba_nhl_{season}_game_log.csv')
-            stats.to_parquet(f'stats/game_log/wsba_nhl_{season}_game_log.parquet',index=False)
+            path = 'stats/game_log' if group == 'skater' else 'stats/game_log/goalie'
+            stat.to_csv(f'{path}/temp.csv',index=False)
+            stats = pd.read_csv(f'{path}/temp.csv')
+            os.remove('temp.csv')
+            stats.to_parquet(f'{path}/wsba_nhl_{season}_game_log{'_goalie' if group == 'goalie' else ''}.parquet',index=False)
+
+def fix_names(arg,seasons):
+    #Stats building
+    for group in arg:
+        for season in seasons:
+            print(f'Fixing names for {group} stats in {season}...')
+
+            group_name = 'Player' if 'skater' in group else 'Goalie'
+            if 'game_log' in group:
+                if 'skater' in group:
+                    path = f'stats/{group[-8:]}/wsba_nhl_{season}_game_log.parquet'
+                else:
+                    path = f'stats/{group[-8:]}/goalie/wsba_nhl_{season}_game_log_goalie.parquet'
+            else:
+                path = f'stats/{group}/wsba_nhl_{season}_{group}.csv'
+            
+            if 'game_log' in group:
+                stats = pd.read_parquet(path)
+            else:
+                stats = pd.read_csv(path)
+
+            missing  = stats.loc[stats[group_name].astype(str)=='0','ID'].drop_duplicates()
+
+            if not missing.to_list():
+                ''
+            else:
+                info = wsba.nhl_scrape_player_data(missing)
+                columns={'playerId':'ID',
+                                'fullName':group_name,
+                                'position':'Position',
+                                'headshot':'Headshot',
+                                'shootsCatches':'Handedness',
+                                'heightInInches':'Height (in)',
+                                'weightInPounds':'Weight (lbs)',
+                                'birthDate':'Birthday' }
+                
+                info = info[list(columns.keys())]
+                complete = pd.merge(stats,info,how='left',left_on=['ID'],right_on=['playerId']).replace({'0':np.nan})
+                
+                for key, value in zip(columns.keys(), columns.values()):
+                    complete[value] = complete[value].combine_first(complete[key])
+                    complete = complete.drop(columns=[key])
+
+                complete.to_csv('wtf.csv')
+                #Add player age
+                complete['Birthday'] = pd.to_datetime(complete['Birthday'],format='mixed')
+                complete['season_year'] = complete['Season'].astype(str).str[4:8].astype(int)
+                complete['Age'] = complete['season_year'] - complete['Birthday'].dt.year
+
+                complete['WSBA'] = complete[group_name]+complete['Team']+complete['Season'].astype(str)
+                complete = complete.sort_values(by=['Player','Season','Team','ID'])
+                
+                if 'game_log' in group:
+                    complete.to_csv('temp.csv',index=False)
+                    pd.read_csv('temp.csv').to_parquet(path,index=False)
+                    os.remove('temp.csv')
+
+                else:
+                    complete.to_csv(path)
 
 def push_to_sheet(seasons, types = ['skaters','team','goalie','info'], msg = 'Data Update'):
     spread = Spread('WSBA - NHL 5v5 Shooting Metrics Public v1.0')
@@ -100,8 +163,8 @@ def push_to_sheet(seasons, types = ['skaters','team','goalie','info'], msg = 'Da
         spread.df_to_sheet(goalie,index=False,sheet='Goalie DB')
 
     if 'info' in types:
-        team_info = pd.read_csv('teaminfo/nhl_teaminfo.csv')
-        country = pd.read_csv('teaminfo/nhl_countryinfo.csv')
+        team_info = pd.read_csv('tools/teaminfo/nhl_teaminfo.csv')
+        country = pd.read_csv('tools/teaminfo/nhl_countryinfo.csv')
 
         spread.df_to_sheet(team_info,index=False,sheet='Team Info')
         spread.df_to_sheet(country,index=False,sheet='Country Info')   

wsba_hockey/evidence/weakside-breakout/wsba_nhl_apps/wsba_nhl_apps/game_stats/app.py

@@ -125,7 +125,7 @@ def server(input, output, session):
     game_info = reactive.Value(None)
 
     def get_schedule():
-        games = pd.read_csv('https://f005.backblazeb2.com/file/weakside-breakout/info/schedule.csv')
+        games = pd.read_csv('https://weakside-breakout.s3.us-east-2.amazonaws.com/info/schedule.csv')
         
         return games.loc[games['gameState'].isin(['OFF','FINAL'])]
 
@@ -139,6 +139,7 @@ def server(input, output, session):
 
         defaults = {
             'game_id':['2024020001'],
+            'title':['true']
         }
 
         for key in defaults.keys():
@@ -180,9 +181,9 @@ def server(input, output, session):
         info = game_info.get()
         season = info['season']
         #Load appropriate dataframe
-        df = pd.read_parquet(f'https://f005.backblazeb2.com/file/weakside-breakout/game_log/wsba_nhl_{season}_game_log.parquet')
-        goalie_df = pd.read_parquet(f'https://f005.backblazeb2.com/file/weakside-breakout/game_log/goalie/wsba_nhl_{season}_game_log_goalie.parquet')
-        pbp = pd.read_parquet(f'https://f005.backblazeb2.com/file/weakside-breakout/pbp/{season}.parquet')
+        df = pd.read_parquet(f'https://weakside-breakout.s3.us-east-2.amazonaws.com/game_log/wsba_nhl_{season}_game_log.parquet')
+        goalie_df = pd.read_parquet(f'https://weakside-breakout.s3.us-east-2.amazonaws.com/game_log/goalie/wsba_nhl_{season}_game_log_goalie.parquet')
+        pbp = pd.read_parquet(f'https://weakside-breakout.s3.us-east-2.amazonaws.com/pbp/{season}.parquet')
 
         game_df.set([df.loc[(df['Game']==info['game_id'])], pbp.loc[(pbp['game_id']==info['game_id'])&(pbp['event_type']=='goal')], goalie_df.loc[(goalie_df['Game']==info['game_id'])]])
 
@@ -247,7 +248,7 @@ def server(input, output, session):
     @output
     @render.text
     def game_header():
-        return game_info.get()['title']
+        return game_info.get()['title'] if active_params()['title'][0] == 'true' else None
 
     @output
     @render.text

wsba_hockey/evidence/weakside-breakout/wsba_nhl_apps/wsba_nhl_apps/goalie/app.py

@@ -0,0 +1,101 @@
+import pandas as pd
+import plot as wsba_plt
+import numpy as np
+from urllib.parse import *
+from shiny import *
+from shinywidgets import output_widget, render_widget
+
+app_ui = ui.page_fluid(
+    ui.tags.style(
+    "body {background:#09090b"
+    "}"
+    ),
+    output_widget("plot_goalie"),
+)
+
+def server(input, output, session):
+    @output()
+    @render_widget
+    def plot_goalie():
+        #Retreive query parameters
+        search = session.input[".clientdata_url_search"]()
+        query = parse_qs(urlparse(search).query)
+        
+        print(query)
+        #If no input data is provided automatically provide a select goalie and plot all 5v5 fenwick shots
+        defaults = {
+            'goalie':['8471679'],
+            'season':['20142015'],
+            'team':['MTL'],
+            'strength_state':['5v5'],
+            'season_type':['2']
+        }
+        
+        for key in defaults.keys():
+            if key not in query.keys():
+                query.update({key:defaults[key]})
+
+        #Iterate through query and parse params with multiple selections
+        for param in query.keys():
+            q_string = query[param][0]
+            query[param] = q_string.split(',')
+
+        print(query)
+        #Determine which season to load based on the input
+        season = query['season'][0]
+        #Load appropriate dataframe
+        df = pd.read_parquet(f'https://weakside-breakout.s3.us-east-2.amazonaws.com/pbp/{season}.parquet')
+        
+        #Prepare dataframe for plotting based on URL parameters
+        df = df.loc[(df['season'].astype(str).isin(query['season']))&(df['season_type'].astype(str).isin(query['season_type']))].replace({np.nan: None})
+        #Return empty rink if no data exists else continue
+        if df.empty:
+            return wsba_plt.wsba_rink(setting='offense',vertical=True)
+        else:
+            rink = wsba_plt.wsba_rink(setting='offense',vertical=True)
+
+            try:
+                plot = wsba_plt.heatmap(df,goalie=query['goalie'][0],team=query['team'][0],events=['missed-shot','shot-on-goal','goal'],strengths=query['strength_state'])
+
+                for trace in plot.data:
+                    rink.add_trace(trace)
+
+                player = query['goalie'][0]
+                season = int(season[0:4])
+                team = query['team'][0]
+                strengths = 'All Situations' if len(query['strength_state']) == 4 else query['strength_state']
+                span = 'Regular Season' if query['season_type'][0]=='2' else 'Playoffs'
+
+                return rink.update_layout( 
+                    title=dict(
+                        text=f'{player} GSAx at {strengths}; {season}-{season+1}, {span}, {team}',
+                        x=0.5, y=0.96,
+                        xanchor='center',
+                        yanchor='top',
+                        font=dict(color='white')
+                    ),
+                ).add_annotation(
+                    text='Lower GSAx',
+                    xref="paper",
+                    yref="paper",
+                    xanchor='right',
+                    yanchor='top',
+                    font=dict(color='white'),
+                    x=0.3,
+                    y=0.04,
+                    showarrow=False
+                ).add_annotation(
+                    text='Higher GSAx',
+                    xref="paper",
+                    yref="paper",
+                    xanchor='right',
+                    yanchor='top',
+                    font=dict(color='white'),
+                    x=0.76,
+                    y=0.04,
+                    showarrow=False
+                )
+            except:
+                return wsba_plt.wsba_rink(setting='offense',vertical=True)
+
+app = App(app_ui, server)

wsba_hockey/evidence/weakside-breakout/wsba_nhl_apps/wsba_nhl_apps/goalie/plot.py

@@ -0,0 +1,71 @@
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+import matplotlib.pyplot as plt
+import rink_plot
+from scipy.interpolate import griddata
+from scipy.ndimage import gaussian_filter
+
+def wsba_rink(setting='full', vertical=False):
+    return rink_plot.rink(setting=setting, vertical=vertical)
+
+def heatmap(df,goalie,team,events,strengths):
+    df['event_team_abbr_2'] = np.where(df['home_team_abbr']==df['event_team_abbr'],df['away_team_abbr'],df['home_team_abbr'])
+    df['strength_state_2'] = df['strength_state'].str[::-1]
+
+    df = df.loc[(df['event_type'].isin(events))&(df['x_adj'].notna())&(df['y_adj'].notna())]
+    df['x'] = np.where(df['x_adj']<0,-df['y_adj'],df['y_adj'])
+    df['y'] = abs(df['x_adj'])
+    df['event_distance'] = abs(df['event_distance'].fillna(0))
+    df = df.loc[(df['event_distance']<=89)&(df['y']<=89)&(df['empty_net']==0)]
+
+    y_min = 0
+    y_max = 100
+
+    df['G'] = (df['event_type']=='goal').astype(int)
+    df['strength_state_2'] = np.where(df['strength_state_2'].isin(['5v5','5v4','4v5']),df['strength_state_2'],'Other')
+        
+    if strengths != 'all':
+        df = df.loc[((df['strength_state_2'].isin(strengths)))]
+
+    [x,y] = np.round(np.meshgrid(np.linspace(-42.5,42.5,85),np.linspace(y_min,y_max,(y_max-y_min))))
+    xgoals = griddata((df['x'],df['y']),df['xG']-df['G'],(x,y),method='cubic',fill_value=0)
+    xgoals_smooth = gaussian_filter(xgoals,sigma=3)
+
+    player_shots = df.loc[(df['event_goalie_id'].astype(str).str.contains(goalie))&(df['event_team_abbr_2']==team)]
+    [x,y] = np.round(np.meshgrid(np.linspace(-42.5,42.5,85),np.linspace(y_min,y_max,(y_max-y_min))))
+    xgoals_player = griddata((player_shots['x'],player_shots['y']),player_shots['xG']-player_shots['G'],(x,y),method='cubic',fill_value=0)
+
+    difference = (gaussian_filter(xgoals_player,sigma = 3)) - xgoals_smooth
+    data_min= difference.min()
+    data_max= difference.max()
+   
+    if abs(data_min) > data_max:
+        data_max = data_min * -1
+    elif data_max > abs(data_min):
+        data_min = data_max * -1
+
+    fig = go.Figure(
+        data = go.Contour(  x=np.linspace(-42.5,42,5,85),
+                            y=np.linspace(y_min,y_max,(y_max-y_min)),
+                            z=xgoals_smooth,
+                            colorscale=[[0.0,'red'],[0.5,'#09090b'],[1.0,'blue']],
+                            connectgaps=True,
+                            contours=dict(
+                                type='levels',
+                                start = data_min,
+                                end = data_max,
+                                size=(data_max-data_min)/11
+                            ),
+                            colorbar=dict(
+                                len = 0.7,
+                                orientation='h',
+                                showticklabels=False,
+                                thickness=15,
+                                yref='paper',
+                                yanchor='top',
+                                y=0
+                            ))
+    )
+
+    return fig