wsba-hockey 1.0.3__py3-none-any.whl → 1.0.4__py3-none-any.whl

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

@@ -0,0 +1,401 @@
+import pandas as pd
+import numpy as np
+import wsba_hockey as wsba
+from urllib.parse import *
+from shiny import *
+from shinywidgets import output_widget, render_widget 
+from name_fix import *
+
+app_ui = ui.page_fluid(
+    ui.tags.link(
+        rel='stylesheet',
+        href='https://fonts.googleapis.com/css2?family=Bebas+Neue&display=swap'
+    ),
+    ui.tags.style(
+        """
+        body {
+            background-color: #09090b;
+            color: white;
+            font-family: 'Bebas Neue', sans-serif;
+        }
+
+        .custom-input input.form-control,
+        .custom-input .selectize-control,
+        .custom-input .selectize-input {
+            background-color: #09090b !important;  /* black background */
+            color: white !important;               /* white font color */
+            border-radius: 4px;
+            border: 1px solid #444;
+        }
+
+        .custom-input .selectize-dropdown,
+        .custom-input .selectize-dropdown-content {
+            background-color: #09090b !important;
+            color: white !important;
+        }          
+
+        .custom-input .selectize-control.multi .item {
+            background-color: #09090b !important;
+            color: white !important;
+            border-radius: 4px;
+            padding: 2px 6px;
+            margin: 2px 4px 2px 0;
+        }
+
+        label.control-label {
+            color: white !important;
+        }   
+
+        .selectize-control.multi {
+            width: 300px !important;
+        }
+
+        .form-row {
+            display: flex;
+            gap: 12px;
+            flex-wrap: wrap;
+            justify-content: center;
+        }
+
+        .submit-button {
+            display: flex;
+            justify-content: center;
+        }
+
+        .hide {
+            display: none;
+        }
+
+        .table thead tr {
+            --bs-table-bg: #09090b;
+            --bs-table-color-state: white;
+        }
+
+        .table thead tr th {
+            white-space: nowrap;
+            text-align: center;
+            color: white;
+            background-color: #09090b;
+        }
+
+        .table tbody tr {
+            --bs-table-bg: #09090b;
+            --bs-table-color-state: white;
+        }
+
+        .table tbody tr td {
+            white-space: nowrap;
+            text-align: center;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            color: white;
+            background-color: #09090b;
+        }
+
+        .table thead th {
+            text-align: center !important;
+        }
+    """
+    ),
+    ui.tags.h2(ui.output_text('game_header'), style="text-align: center;"),
+    ui.tags.h4('Team Stats'),
+    ui.output_data_frame("team_stats"),
+    ui.tags.h4('Scoring Summary'),
+    ui.output_data_frame("scoring_summary"),
+    ui.output_ui("table_filters"),
+    ui.row(
+        ui.column(6, ui.tags.h4(ui.output_text('away_header'))),
+        ui.column(6, ui.tags.h4(ui.output_text('home_header')))
+    ),
+    ui.row(
+        ui.column(6, ui.output_data_frame("away_stats")),
+        ui.column(6, ui.output_data_frame("home_stats"))
+    ),
+    ui.row(
+        ui.column(6, ui.tags.h4(ui.output_text('away_goalie_header'))),
+        ui.column(6, ui.tags.h4(ui.output_text('home_goalie_header')))
+    ),
+    ui.row(
+        ui.column(6, ui.output_data_frame("away_goalie")),
+        ui.column(6, ui.output_data_frame("home_goalie"))
+    )
+)
+
+def server(input, output, session):
+    query = reactive.Value(None)
+    game_info = reactive.Value(None)
+
+    def get_schedule():
+        games = pd.read_csv('https://f005.backblazeb2.com/file/weakside-breakout/info/schedule.csv')
+        
+        return games.loc[games['gameState'].isin(['OFF','FINAL'])]
+
+    @reactive.Effect
+    def query_params():
+        #Retreive query parameters
+        search = session.input[".clientdata_url_search"]()
+        q = parse_qs(urlparse(search).query)
+
+        print(q)
+
+        defaults = {
+            'game_id':['2024020001'],
+        }
+
+        for key in defaults.keys():
+            if key not in q.keys():
+                q.update({key:defaults[key]})
+
+        query.set(q)
+        
+    def active_params():
+        return query.get() or {}
+
+    @reactive.Effect
+    def get_game_info():
+        #Load params
+        query = active_params()
+
+        #Load game data
+        game = get_schedule()
+        game = game.loc[game['id'].astype(str).str.replace('.0','')==query['game_id'][0]]
+
+        game_info.set({
+            'game_id':game['id'].iloc[0],
+            'season':game['season'].iloc[0],
+            'title':game['game_title'].iloc[0],
+            'date':game['date'].iloc[0],
+            'away_team_abbr':game['away_team_abbr'].iloc[0],
+            'home_team_abbr':game['home_team_abbr'].iloc[0],
+            'away_logo':game['awayTeam.darkLogo'].iloc[0],
+            'home_logo':game['homeTeam.darkLogo'].iloc[0],
+            'away_score':game['awayTeam.score'].iloc[0],
+            'home_score':game['homeTeam.score'].iloc[0],
+        })
+        print(game_info.get())
+
+    game_df = reactive.Value(None)
+    @reactive.Effect
+    def active_game():
+        #Determine which season to load based on the input game_id
+        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')
+
+        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'])]])
+
+    @output
+    @render.ui
+    def table_filters():
+        all_strengths = ['4v5','5v4','5v5','Other','All']
+        return ui.panel_well(
+            ui.tags.div(
+            {"class": "form-row custom-input"},
+                ui.input_selectize('stat_type','Type',['Individual','On-Ice']),
+                ui.input_selectize('strength_state','Strength',all_strengths,selected='5v5'),
+            )
+        )
+
+    @output
+    @render.data_frame
+    def team_stats():
+        df = game_df.get()[0]
+        info = game_info.get()
+
+        df = df.loc[df['Strength']=='All'].groupby('Team').agg(
+            Fenwick=('Fi','sum'),
+            xG=('xGi','sum'),
+            Hits=('HF','sum'),
+            Give=('Give','sum'),
+            Take=('Take','sum'),
+            PIM=('PIM','sum')
+        ).reset_index()
+
+        score = pd.DataFrame([[info['away_team_abbr'],
+                               info['away_score']],
+                               [info['home_team_abbr'],
+                               info['home_score']]],columns=['Team','Goals'])
+        
+        df = pd.merge(df,score,how='left')
+        df = df[['Team','Goals','Fenwick','xG','Hits','Give','Take','PIM']]
+
+        df['xG'] = df['xG'].round(2)
+
+        print(df)
+
+        return render.DataTable(df,height='fit-content')
+
+    @output
+    @render.data_frame
+    def scoring_summary():
+        pbp = game_df.get()[1]
+ 
+        pbp = pbp[['event_num','period','seconds_elapsed','strength_state','description','away_score','home_score','xG']].rename(columns={
+                    'event_num':'#',
+                    'seconds_elapsed':'Seconds',
+                    'strength_state':'Strength State',
+                    'away_score':'Away Score',
+                    'home_score':'Home Score'
+                })
+                
+        pbp['xG'] = (pbp['xG']*100).round(4)
+
+        return render.DataTable(pbp, height='fit-content')
+
+    @output
+    @render.text
+    def game_header():
+        return game_info.get()['title']
+
+    @output
+    @render.text
+    def away_header():
+        team = game_info.get()['away_team_abbr']
+
+        return f'{team} Stats'
+
+    @output
+    @render.text
+    def home_header():
+        team = game_info.get()['home_team_abbr']
+
+        return f'{team} Stats'
+
+    @output
+    @render.text
+    def away_goalie_header():
+        team = game_info.get()['away_team_abbr']
+
+        return f'{team} Goalie Stats'
+
+    @output
+    @render.text
+    def home_goalie_header():
+        team = game_info.get()['home_team_abbr']
+
+        return f'{team} Goalie Stats'
+    
+    @output
+    @render.data_frame
+    def away_stats():
+        df = game_df.get()[0]
+        info = game_info.get()
+
+        if input.stat_type() == 'Individual':
+            cols = [
+                'Player','ID','Position','Handedness','TOI','Gi','A1','A2','P1','P','Give','Take','HF','HA',
+                'Fi','xGi'
+            ]
+        else:
+            cols = [
+                'Player','ID','Position','Handedness','TOI','GF','GA','FF','FA','xGF','xGA','GF%','FF%','xGF%'
+            ]
+
+        df = df.loc[(df['Team']==info['away_team_abbr'])&(df['Strength']==input.strength_state()),cols]
+
+        for col in ['TOI','xGi','xGF','xGA','GF%','FF%','xGF%']:
+            try:
+                if '%' in col:
+                    df[col] = (df[col]*100).round(2).astype(str) + '%'
+                else:
+                    df[col] = df[col].round(2)
+            except:
+                continue
+        
+        df = fix_names(df)
+
+        return render.DataTable(df.rename(columns={
+            'Gi':'G',
+            'Fi':'iFF',
+            'xGi':'ixG'
+        }).drop(columns=['ID']).rename(columns={'Position':'POS','Handedness':'Hand'}))
+    
+    @output
+    @render.data_frame
+    def home_stats():
+        df = game_df.get()[0]
+        info = game_info.get()
+
+        if input.stat_type() == 'Individual':
+            cols = [
+                'Player','ID','TOI','Position','Handedness','Gi','A1','A2','P1','P','Give','Take','HF','HA',
+                'Fi','xGi'
+            ]
+        else:
+            cols = [
+                'Player','ID','TOI','Position','Handedness','GF','GA','FF','FA','xGF','xGA','GF%','FF%','xGF%'
+            ]
+
+        df = df.loc[(df['Team']==info['home_team_abbr'])&(df['Strength']==input.strength_state()),cols]
+
+        for col in ['TOI','xGi','xGF','xGA','GF%','FF%','xGF%']:
+            try:
+                if '%' in col:
+                    df[col] = (df[col]*100).round(2).astype(str) + '%'
+                else:
+                    df[col] = df[col].round(2)
+            except:
+                continue
+        
+        df = fix_names(df)
+
+        return render.DataTable(df.rename(columns={
+            'Gi':'G',
+            'Fi':'iFF',
+            'xGi':'ixG'
+        }).drop(columns=['ID']).rename(columns={'Position':'POS','Handedness':'Hand'}))
+
+    @output
+    @render.data_frame
+    def away_goalie():
+        df = game_df.get()[2]
+        info = game_info.get()
+
+        cols = [
+            'Goalie','ID','TOI','Position','Handedness','GA','FA','xGA','GSAx'
+        ]
+
+        df = df.loc[(df['Team']==info['away_team_abbr'])&(df['Strength']==input.strength_state()),cols]
+
+        for col in ['TOI','xGA','GSAx']:
+            try:
+                if '%' in col:
+                    df[col] = (df[col]*100).round(2).astype(str) + '%'
+                else:
+                    df[col] = df[col].round(2)
+            except:
+                continue
+        
+        df = fix_names(df,'Goalie')
+
+        return render.DataTable(df.drop(columns=['ID']).rename(columns={'Position':'POS','Handedness':'Hand'}))
+    
+    @output
+    @render.data_frame
+    def home_goalie():
+        df = game_df.get()[2]
+        info = game_info.get()
+
+        cols = [
+            'Goalie','ID','TOI','Position','Handedness','GA','FA','xGA','GSAx'
+        ]
+
+        df = df.loc[(df['Team']==info['home_team_abbr'])&(df['Strength']==input.strength_state()),cols]
+
+        for col in ['TOI','xGA','GSAx']:
+            try:
+                if '%' in col:
+                    df[col] = (df[col]*100).round(2).astype(str) + '%'
+                else:
+                    df[col] = df[col].round(2)
+            except:
+                continue
+        
+        df = fix_names(df,'Goalie')
+
+        return render.DataTable(df.drop(columns=['ID']).rename(columns={'Position':'POS','Handedness':'Hand'}))
+    
+app = App(app_ui, server)

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

@@ -0,0 +1,47 @@
+import requests as rs
+import pandas as pd
+import numpy as np
+
+def scrape_info(player_ids):
+    #Given player id, return player information
+    infos = []
+    for player_id in player_ids:
+        player_id = int(player_id)
+        api = f'https://api-web.nhle.com/v1/player/{player_id}/landing'
+
+        data = pd.json_normalize(rs.get(api).json())
+
+        #Add name column
+        data['fullName'] = (data['firstName.default'] + " " + data['lastName.default']).str.upper()
+
+        #Append
+        infos.append(data)
+
+    df = pd.concat(infos)
+    #Return: player data
+    return df
+
+def fix_names(stats,name='Player'):
+    missing = stats.loc[stats[name]=='0']
+    stats = stats.loc[stats[name]!='0']  
+    
+    if not missing.empty:
+        data = scrape_info(missing['ID'])[['fullName','playerId','position','shootsCatches']].rename(columns={
+            'playerId':'ID',
+            'fullName':'Player',
+            'position':'Position',
+            'headshot':'Headshot',
+            'heightInInches':'Height (in)',
+            'weightInPounds':'Weight (lbs)',
+            'birthDate':'Birthday',
+            'birthCountry':'Nationality',
+            'shootsCatches':'Handedness'}) 
+
+        missing = missing.drop(columns=[name,'Position','Handedness'])         
+        miss = pd.merge(missing,data,how='left',on=['ID'])
+
+        df = pd.concat([stats,miss]).sort_values([name,'ID'])
+
+        return df
+    else:
+        return stats

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

@@ -0,0 +1,108 @@
+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_skater"),
+)
+
+def server(input, output, session):
+    @output()
+    @render_widget
+    def plot_skater():
+        #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 skater and plot all 5v5 fenwick shots
+        defaults = {
+            'skater':['8473419'],
+            'season':['20182019'],
+            'team':['BOS'],
+            '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://f005.backblazeb2.com/file/weakside-breakout/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()
+        else:
+            rink = wsba_plt.wsba_rink()
+
+            try:
+                for_plot = wsba_plt.heatmap(df,skater=query['skater'][0],team=query['team'][0],events=['missed-shot','shot-on-goal','goal'],strengths=query['strength_state'],onice='for')
+                against_plot = wsba_plt.heatmap(df,skater=query['skater'][0],team=query['team'][0],events=['missed-shot','shot-on-goal','goal'],strengths=query['strength_state'],onice='against')
+
+                for trace in for_plot.data:
+                    rink.add_trace(trace)
+                
+                for trace in against_plot.data:
+                    rink.add_trace(trace)
+
+                try:
+                    player = df.loc[df['event_player_1_id'].astype(str).str.replace('.0','')==query['skater'][0],'event_player_1_name'].to_list()[0]
+                except:
+                    player = query['skater'][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} On-Ice xG 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 xG',
+                    xref="paper",
+                    yref="paper",
+                    xanchor='right',
+                    yanchor='top',
+                    font=dict(color='white'),
+                    x=0.3,
+                    y=0.04,
+                    showarrow=False
+                ).add_annotation(
+                    text='Higher xG',
+                    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()
+
+app = App(app_ui, server)

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

@@ -0,0 +1,93 @@
+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,skater,team,events,strengths,onice):
+    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())]
+    if onice == 'for':
+        df['x'] = abs(df['x_adj'])
+        df['y'] = np.where(df['x_adj']<0,-df['y_adj'],df['y_adj'])
+        df['event_distance'] = abs(df['event_distance'].fillna(0))
+        df = df.loc[(df['event_distance']<=89)&(df['x']<=89)&(df['empty_net']==0)]
+
+        x_min = 0
+        x_max = 100
+    else:
+        df['x'] = -abs(df['x_adj'])
+        df['y'] = np.where(df['x_adj']>0,-df['y_adj'],df['y_adj'])
+        df['event_distance'] = -abs(df['event_distance'])
+        df = df.loc[(df['event_distance']>-89)&(df['x']>-89)&(df['empty_net']==0)]
+
+        x_min = -100
+        x_max = 0
+
+    df['home_on_ice'] = df['home_on_1_id'].astype(str) + ";" + df['home_on_2_id'].astype(str) + ";" + df['home_on_3_id'].astype(str) + ";" + df['home_on_4_id'].astype(str) + ";" + df['home_on_5_id'].astype(str) + ";" + df['home_on_6_id'].astype(str)
+    df['away_on_ice'] = df['away_on_1_id'].astype(str) + ";" + df['away_on_2_id'].astype(str) + ";" + df['away_on_3_id'].astype(str) + ";" + df['away_on_4_id'].astype(str) + ";" + df['away_on_5_id'].astype(str) + ";" + df['away_on_6_id'].astype(str)
+
+    df['onice_for'] = np.where(df['home_team_abbr']==df['event_team_abbr'],df['home_on_ice'],df['away_on_ice'])
+    df['onice_against'] = np.where(df['away_team_abbr']==df['event_team_abbr'],df['home_on_ice'],df['away_on_ice'])
+
+    df['strength_state'] = np.where(df['strength_state'].isin(['5v5','5v4','4v5']),df['strength_state'],'Other')
+        
+    if strengths != 'all':
+        if onice == 'against':
+            df = df.loc[((df['strength_state_2'].isin(strengths)))]
+        else:
+            df = df.loc[((df['strength_state'].isin(strengths)))]
+
+    [x,y] = np.round(np.meshgrid(np.linspace(x_min,x_max,(x_max-x_min)),np.linspace(-42.5,42.5,85)))
+    xgoals = griddata((df['x'],df['y']),df['xG'],(x,y),method='cubic',fill_value=0)
+    xgoals = np.where(xgoals < 0,0,xgoals)
+    xgoals_smooth = gaussian_filter(xgoals,sigma=3)
+
+    if onice == 'for':
+        player_shots = df.loc[(df['onice_for'].str.contains(skater))&(df['event_team_abbr']==team)]
+    else:
+        player_shots = df.loc[(df['onice_against'].str.contains(skater))&(df['event_team_abbr_2']==team)]
+    [x,y] = np.round(np.meshgrid(np.linspace(x_min,x_max,(x_max-x_min)),np.linspace(-42.5,42.5,85)))
+    xgoals_player = griddata((player_shots['x'],player_shots['y']),player_shots['xG'],(x,y),method='cubic',fill_value=0)
+    xgoals_player = np.where(xgoals_player < 0,0,xgoals_player)
+
+    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(x_min,x_max,(x_max-x_min)),
+                            y=np.linspace(-42.5,42.5,85),
+                            z=difference,
+                            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