wsba-hockey 1.1.3__py3-none-any.whl → 1.1.6__py3-none-any.whl

wsba_hockey/evidence/weakside-breakout/wsba_nhl_apps/wsba_nhl_apps/line-combos/rink_plot.py

@@ -0,0 +1,245 @@
+
+import numpy as np
+import plotly.graph_objects as go
+import io
+import base64
+import requests as rs
+from PIL import Image
+
+def rink(setting = "full", vertical = False):
+    '''
+    Function to plot rink in Plotly. Takes 2 arguments :
+
+    setting : full (default) for full ice, offense positive half of the ice, ozone positive quarter of ice, defense for negative half of the ice, dzone for negative quarter of the ice, and neutral for the neutral zone
+    vertical : True if you want a vertical rink, False (default) is for an horizontal rink
+
+    '''
+
+    def faceoff_circle(x, y, outer=True):
+        segments = []
+        theta = np.linspace(0, 2*np.pi, 300)
+        if outer:
+            # Outer circle
+            x_outer = x + 15*np.cos(theta)
+            y_outer = y + 15*np.sin(theta)
+            outer_circle = go.Scatter(x=x_outer, y=y_outer, mode='lines', line=dict(width=2, color='red'), showlegend=False, hoverinfo='skip')
+
+            segments.append(outer_circle)
+
+        # Inner circle
+        x_inner = x + np.cos(theta)
+        y_inner = y + np.sin(theta)
+        inner_circle = go.Scatter(x=x_inner, y=y_inner, mode='lines', fill='toself', fillcolor='rgba(255, 0, 0, 0.43)', line=dict(color='rgba(255, 0, 0, 1)', width=2), showlegend=False, hoverinfo='skip')
+        
+        segments.append(inner_circle)
+        
+        return segments  #segments
+    
+    fig = go.Figure()
+
+    if vertical :
+        setting_dict = {
+            "full" : [-101, 101],
+            "offense" : [0, 101],
+            "ozone" : [25, 101],
+            "defense" : [-101, 0],
+            "dzone" : [-101, -25],
+            "neutral" : [-25,25]
+        }
+        fig.update_layout(xaxis=dict(range=[-42.6, 42.6], showgrid=False, zeroline=False, showticklabels=False, constrain="domain"), yaxis=dict(range=setting_dict[setting], showgrid=False, zeroline=False, showticklabels=False, constrain="domain"),
+                        showlegend=False, autosize=True, template="plotly_white")
+        fig.update_yaxes(
+            scaleanchor="x",
+            scaleratio=1,
+        )
+        def goal_crease(flip=1):
+            x_seq = np.linspace(-4, 4, 100)
+            x_goal = np.concatenate(([-4], x_seq, [4]))
+            y_goal = flip * np.concatenate(([89], 83 + x_seq**2/4**2*1.5, [89]))
+            goal_crease = go.Scatter(x=x_goal, y=y_goal, fill='toself', fillcolor='rgba(173, 216, 230, 0.3)', line=dict(color='red'))
+            return goal_crease
+
+        # Outer circle
+        theta = np.linspace(0, 2*np.pi, 300)
+        x_outer = 15 * np.cos(theta)
+        y_outer = 15 * np.sin(theta)
+        fig.add_trace(go.Scatter(x=x_outer, y=y_outer, mode='lines', line=dict(color='royalblue', width=2), showlegend=False, hoverinfo='skip'))
+        # Inner circle
+        theta2 = np.linspace(np.pi/2, 3*np.pi/2, 300)
+        x_inner = 42.5 + 10 * np.cos(theta2)
+        y_inner = 10 * np.sin(theta2)
+        fig.add_trace(go.Scatter(x=x_inner, y=y_inner, mode='lines', line=dict(color='red', width=2), showlegend=False, hoverinfo='skip'))
+        # Rink boundaries
+        fig.add_shape(type='rect', xref='x', yref='y', x0=-42.5, y0=25, x1=42.5, y1=26, line=dict(color='royalblue', width=1), fillcolor='royalblue', opacity=1)
+        fig.add_shape(type='rect', xref='x', yref='y', x0=-42.5, y0=-25, x1=42.5, y1=-26, line=dict(color='royalblue', width=1), fillcolor='royalblue', opacity=1)
+        fig.add_shape(type='rect', xref='x', yref='y', x0=-42.5, y0=-0.5, x1=42.5, y1=0.5, line=dict(color='red', width=2), fillcolor='red')
+        
+        # Goal crease
+        fig.add_trace(goal_crease())
+        fig.add_trace(goal_crease(-1))
+        # Goal lines
+        goal_line_extreme = 42.5 - 28 + np.sqrt(28**2 - (28-11)**2)
+        fig.add_shape(type='line', xref='x', yref='y', x0=-goal_line_extreme, y0=89, x1=goal_line_extreme, y1=89, line=dict(color='red', width=2))
+        fig.add_shape(type='line', xref='x', yref='y', x0=-goal_line_extreme, y0=-89, x1=goal_line_extreme, y1=-89, line=dict(color='red', width=2))
+
+        # Faceoff circles
+        fig.add_traces(faceoff_circle(-22, 69))
+        fig.add_traces(faceoff_circle(22, 69))
+        fig.add_traces(faceoff_circle(-22, -69))
+        fig.add_traces(faceoff_circle(22, -69))
+        fig.add_traces(faceoff_circle(-22, -20, False))
+        fig.add_traces(faceoff_circle(22, -20, False))
+        fig.add_traces(faceoff_circle(-22, 20, False))
+        fig.add_traces(faceoff_circle(22, 20, False))
+        
+        # Sidelines
+        theta_lines = np.linspace(0, np.pi/2, 20)
+        x_lines1 = np.concatenate(([-42.5], -42.5 + 28 - 28*np.cos(theta_lines), 42.5 - 28 + 28*np.cos(np.flip(theta_lines))))
+        y_lines1 = np.concatenate(([15], 72 + 28*np.sin(theta_lines), 72 + 28*np.sin(np.flip(theta_lines))))
+        x_lines2 = np.concatenate(([-42.5], -42.5 + 28 - 28*np.cos(theta_lines), 42.5 - 28 + 28*np.cos(np.flip(theta_lines))))
+        y_lines2 = np.concatenate(([15], -72 - 28*np.sin(theta_lines), -72 - 28*np.sin(np.flip(theta_lines))))
+        fig.add_trace(go.Scatter(x=x_lines1, y=y_lines1, mode='lines', line=dict(color='white', width=2), showlegend=False, hoverinfo='skip'))
+        fig.add_trace(go.Scatter(x=x_lines2, y=y_lines2, mode='lines', line=dict(color='white', width=2), showlegend=False, hoverinfo='skip'))
+        fig.add_shape(type='line', xref='x', yref='y', x0=42.5, y0=-72.5, x1=42.5, y1=72.5, line=dict(color='white', width=2))
+        fig.add_shape(type='line', xref='x', yref='y', x0=-42.5, y0=-72.5, x1=-42.5, y1=72.5, line=dict(color='white', width=2))
+        
+        # Add goals
+        goal_width = 6     # feet
+        goal_depth = 4     # feet
+
+        # Top goal
+        fig.add_shape(
+            type="rect",
+            xref="x",
+            yref="y",
+            x0=-goal_width / 2,
+            y0=89,
+            x1=goal_width / 2,
+            y1=89 + goal_depth,
+            line=dict(color="red", width=2),
+        )
+        # Bottom goal
+        fig.add_shape(
+            type="rect",
+            xref="x",
+            yref="y",
+            x0=-goal_width / 2,
+            y0=-89 - goal_depth,
+            x1=goal_width / 2,
+            y1=-89,
+            line=dict(color="red", width=2),
+        )
+
+    else : 
+        setting_dict = {
+            "full" : [-101, 101],
+            "offense" : [0, 101],
+            "ozone" : [25, 101],
+            "defense" : [-101, 0],
+            "dzone" : [-101, -25]
+        }
+        fig.update_layout(xaxis=dict(range=setting_dict[setting], showgrid=False, zeroline=False, showticklabels=False), yaxis=dict(range=[-42.6, 42.6], showgrid=False, zeroline=False, showticklabels=False, constrain="domain"),
+                        showlegend=True, autosize =True, template="plotly_white")
+        fig.update_yaxes(
+            scaleanchor="x",
+            scaleratio=1,
+        )
+        def goal_crease(flip=1):
+            y_seq = np.linspace(-4, 4, 100)
+            y_goal = np.concatenate(([-4], y_seq, [4]))
+            x_goal = flip * np.concatenate(([89], 83 + y_seq**2/4**2*1.5, [89]))
+            goal_crease = go.Scatter(x=x_goal, y=y_goal, fill='toself', fillcolor='rgba(173, 216, 230, 0.3)', line=dict(color='red'), showlegend=False, hoverinfo='skip')
+            return goal_crease
+        
+        # Outer circle
+        theta = np.linspace(0, 2 * np.pi, 300)
+        x_outer = 15 * np.sin(theta)
+        y_outer = 15 * np.cos(theta)
+        fig.add_trace(go.Scatter(x=x_outer, y=y_outer, mode='lines', line=dict(color='royalblue', width=2), showlegend=False, hoverinfo='skip'))
+        # Inner circle
+        theta2 = np.linspace(3 * np.pi / 2, np.pi / 2, 300)  # Update theta2 to rotate the plot by 180 degrees
+        x_inner = 10 * np.sin(theta2)  # Update x_inner to rotate the plot by 180 degrees
+        y_inner = -42.5 - 10 * np.cos(theta2)  # Update y_inner to rotate the plot by 180 degrees
+        fig.add_trace(go.Scatter(x=x_inner, y=y_inner, mode='lines', line=dict(color='red', width=2), showlegend=False, hoverinfo='skip'))
+        
+        # Rink boundaries
+        fig.add_shape(type='rect', xref='x', yref='y', x0=25, y0=-42.5, x1=26, y1=42.5, line=dict(color='royalblue', width=1), fillcolor='royalblue', opacity=1)
+        fig.add_shape(type='rect', xref='x', yref='y', x0=-25, y0=-42.5, x1=-26, y1=42.5, line=dict(color='royalblue', width=1), fillcolor='royalblue', opacity=1)
+        fig.add_shape(type='rect', xref='x', yref='y', x0=-0.5, y0=-42.5, x1=0.5, y1=42.5, line=dict(color='red', width=2), fillcolor='red')
+        # Goal crease
+        fig.add_trace(goal_crease())
+        fig.add_trace(goal_crease(-1))
+        # Goal lines
+        goal_line_extreme = 42.5 - 28 + np.sqrt(28 ** 2 - (28 - 11) ** 2)
+        fig.add_shape(type='line', xref='x', yref='y', x0=89, y0=-goal_line_extreme, x1=89, y1=goal_line_extreme, line=dict(color='red', width=2))
+        fig.add_shape(type='line', xref='x', yref='y', x0=-89, y0=-goal_line_extreme, x1=-89, y1=goal_line_extreme, line=dict(color='red', width=2))
+        # Faceoff circles
+        fig.add_traces(faceoff_circle(-69, -22))
+        fig.add_traces(faceoff_circle(-69, 22))
+        fig.add_traces(faceoff_circle(69, -22))
+        fig.add_traces(faceoff_circle(69, 22))
+        fig.add_traces(faceoff_circle(-20, -22, False))
+        fig.add_traces(faceoff_circle(-20, 22, False))
+        fig.add_traces(faceoff_circle(20, -22, False))
+        fig.add_traces(faceoff_circle(20, 22, False))
+
+        # Sidelines
+        theta_lines = np.linspace(0, np.pi / 2, 20)
+        x_lines1 = np.concatenate(([15], 72 + 28 * np.sin(theta_lines), 72 + 28 * np.sin(np.flip(theta_lines))))
+        y_lines1 = np.concatenate(([-42.5], -42.5 + 28 - 28 * np.cos(theta_lines), 42.5 - 28 + 28 * np.cos(np.flip(theta_lines))))
+        x_lines2 = np.concatenate(([15], -72 - 28 * np.sin(theta_lines), -72 - 28 * np.sin(np.flip(theta_lines))))
+        y_lines2 = np.concatenate(([-42.5], -42.5 + 28 - 28 * np.cos(theta_lines), 42.5 - 28 + 28 * np.cos(np.flip(theta_lines))))
+        fig.add_trace(go.Scatter(x=x_lines1, y=y_lines1, mode='lines', line=dict(color='white', width=2), showlegend=False, hoverinfo='skip'))
+        fig.add_trace(go.Scatter(x=x_lines2, y=y_lines2, mode='lines', line=dict(color='white', width=2), showlegend=False, hoverinfo='skip'))
+        fig.add_shape(type='line', xref='x', yref='y', x0=-72.5, y0=-42.5, x1=72.5, y1=-42.5, line=dict(color='white', width=2))
+        fig.add_shape(type='line', xref='x', yref='y', x0=-72.5, y0=42.5, x1=72.5, y1=42.5, line=dict(color='white', width=2))
+
+        # Add goals
+        goal_width = 6     # feet
+        goal_depth = 4     # feet
+
+        # Right goal
+        fig.add_shape(
+            type="rect",
+            xref="x",
+            yref="y",
+            x0=89,
+            y0=-goal_width / 2,
+            x1=89 + goal_depth,
+            y1=goal_width / 2,
+            line=dict(color="red", width=2),
+        )
+        # Left goal
+        fig.add_shape(
+            type="rect",
+            xref="x",
+            yref="y",
+            x0=-89 - goal_depth,
+            y0=-goal_width / 2,
+            x1=-89,
+            y1=goal_width / 2,
+            line=dict(color="red", width=2),
+        )
+
+    # Add logo
+    logo = Image.open(rs.get('https://weakside-breakout.s3.us-east-2.amazonaws.com/utils/wsba.png',stream=True).raw)
+
+    fig.add_layout_image(
+        dict(
+            source=logo,
+            xref="x",
+            yref="y",
+            x=-12,
+            y=12,
+            sizex=24,
+            sizey=24,
+            sizing="stretch",
+            opacity=1)
+        )
+    
+    #Set background to transparent
+    fig.update_layout(
+        paper_bgcolor="rgba(0,0,0,0)", 
+        plot_bgcolor="rgba(0,0,0,0)"
+    )
+    return fig

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

@@ -26,8 +26,8 @@ def server(input, output, session):
         #If no input data is provided automatically provide a select skater and plot all 5v5 fenwick shots
         #If no input data is provided automatically provide a select skater and plot all 5v5 fenwick shots
         defaults = {
-            'seasona':['20242025,20242025'],
-            'teama':['EDM,FLA'],
+            'seasons':['20242025,20242025'],
+            'teams':['EDM,FLA'],
             'strength_state':['5v5'],
             'season_type':['2']
         }

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

@@ -247,6 +247,7 @@ def server(input, output, session):
             return wsba_plt.wsba_rink()
         else:
             game_title = df['game_title'].to_list()[0]
+            print(game_title)
             colors = wsba_plt.colors(df)
             rink = wsba_plt.wsba_rink()
 

wsba_hockey/tools/agg.py

@@ -30,6 +30,7 @@ def calc_indv(pbp,game_strength,second_group):
     ep1 = (
         pbp.loc[pbp['event_type'].isin(["goal", "shot-on-goal", "missed-shot","blocked-shot",'hit','giveaway','takeaway','faceoff','penalty'])].groupby(raw_group_1).agg(
         Gi=('event_type', lambda x: (x == "goal").sum()),
+        Si=('event_type', lambda x: (x.isin(['shot-on-goal','goal'])).sum()),
         Fi=('event_type', lambda x: (x.isin(fenwick_events)).sum()),
         Ci=('event_type', lambda x: (x.isin(fenwick_events+['blocked-shot'])).sum()),
         xGi=('xG', 'sum'),
@@ -80,6 +81,7 @@ def calc_indv(pbp,game_strength,second_group):
         shot = (
             pbp.loc[(pbp['event_type'].isin(["goal", "shot-on-goal", "missed-shot"])&(pbp['shot_type']==type))].groupby(raw_group_1).agg(
             Gi=('event_type', lambda x: (x == "goal").sum()),
+            Si=('event_type', lambda x: (x.isin(['shot-on-goal','goal'])).sum()),
             Fi=('event_type', lambda x: (x != "blocked-shot").sum()),
             xGi=('xG', 'sum'),
         ).reset_index().rename(columns={'event_player_1_id': 'ID', 'event_team_abbr': 'Team', 'season': 'Season', 'game_id':'Game'})
@@ -87,6 +89,7 @@ def calc_indv(pbp,game_strength,second_group):
 
         shot = shot.rename(columns={
             'Gi':f'{type.capitalize()}Gi',
+            'Si':f'{type.capitalize()}Si',
             'Fi':f'{type.capitalize()}Fi',
             'xGi':f'{type.capitalize()}xGi',
         })
@@ -96,6 +99,7 @@ def calc_indv(pbp,game_strength,second_group):
 
     indv['P1'] = indv['Gi']+indv['A1']
     indv['P'] = indv['P1']+indv['A2']
+    indv['Shi%'] = indv['Gi']/indv['Si']
     indv['xGi/Fi'] = indv['xGi']/indv['Fi']
     indv['Gi/xGi'] = indv['Gi']/indv['xGi']
     indv['Fshi%'] = indv['Gi']/indv['Fi']
@@ -134,6 +138,8 @@ def calc_onice(pbp,game_strength,second_group):
         df['xGA'] = np.where(df['event_team_abbr'] == df[opp_col], df['xG'], 0)
         df['GF'] = np.where((df['event_type'] == "goal") & (df['event_team_abbr'] == df[team_col]), 1, 0)
         df['GA'] = np.where((df['event_type'] == "goal") & (df['event_team_abbr'] == df[opp_col]), 1, 0)
+        df['SF'] = np.where((df['event_type'].isin(['shot-on-goal','goal'])) & (df['event_team_abbr'] == df[team_col]), 1, 0)
+        df['SA'] = np.where((df['event_type'].isin(['shot-on-goal','goal'])) & (df['event_team_abbr'] == df[opp_col]), 1, 0)
         df['FF'] = np.where((df['event_type'].isin(fenwick_events)) & (df['event_team_abbr'] == df[team_col]), 1, 0)
         df['FA'] = np.where((df['event_type'].isin(fenwick_events)) & (df['event_team_abbr'] == df[opp_col]), 1, 0)
         df['CF'] = np.where((df['event_type'].isin(fenwick_events+['blocked-shot'])) & (df['event_team_abbr'] == df[team_col]), 1, 0)
@@ -149,6 +155,8 @@ def calc_onice(pbp,game_strength,second_group):
             FA=('FA', 'sum'),
             GF=('GF', 'sum'),
             GA=('GA', 'sum'),
+            SF=('SF', 'sum'),
+            SA=('SA', 'sum'),
             xGF=('xGF', 'sum'),
             xGA=('xGA', 'sum'),
             CF=('CF','sum'),
@@ -170,6 +178,8 @@ def calc_onice(pbp,game_strength,second_group):
             FA=('FA', 'sum'),
             GF=('GF', 'sum'),
             GA=('GA', 'sum'),
+            SF=('SF', 'sum'),
+            SA=('SA', 'sum'),
             xGF=('xGF', 'sum'),
             xGA=('xGA', 'sum'),
             CF=('CF','sum'),
@@ -179,15 +189,18 @@ def calc_onice(pbp,game_strength,second_group):
             DZF=('DZF','sum')
     ).reset_index()
 
+    onice_stats['ShF%'] = onice_stats['GF']/onice_stats['SF']
     onice_stats['xGF/FF'] = onice_stats['xGF']/onice_stats['FF']
     onice_stats['GF/xGF'] = onice_stats['GF']/onice_stats['xGF']
     onice_stats['FshF%'] = onice_stats['GF']/onice_stats['FF']
+    onice_stats['ShA%'] = onice_stats['GA']/onice_stats['SA']
     onice_stats['xGA/FA'] = onice_stats['xGA']/onice_stats['FA']
     onice_stats['GA/xGA'] = onice_stats['GA']/onice_stats['xGA']
     onice_stats['FshA%'] = onice_stats['GA']/onice_stats['FA']
     onice_stats['OZF%'] = onice_stats['OZF']/(onice_stats['OZF']+onice_stats['NZF']+onice_stats['DZF'])
     onice_stats['NZF%'] = onice_stats['NZF']/(onice_stats['OZF']+onice_stats['NZF']+onice_stats['DZF'])
     onice_stats['DZF%'] = onice_stats['DZF']/(onice_stats['OZF']+onice_stats['NZF']+onice_stats['DZF'])
+    onice_stats['GSAx'] = onice_stats['xGA']-onice_stats['GA']
 
     return onice_stats
 
@@ -206,6 +219,8 @@ def calc_team(pbp,game_strength,second_group):
         pbp['xGA'] = np.where(pbp['event_team_abbr'] == pbp[f'{team[1]}_team_abbr'], pbp['xG'], 0)
         pbp['GF'] = np.where((pbp['event_type'] == "goal") & (pbp['event_team_abbr'] == pbp[f'{team[0]}_team_abbr']), 1, 0)
         pbp['GA'] = np.where((pbp['event_type'] == "goal") & (pbp['event_team_abbr'] == pbp[f'{team[1]}_team_abbr']), 1, 0)
+        pbp['SF'] = np.where((pbp['event_type'].isin(['shot-on-goal','goal'])) & (pbp['event_team_abbr'] == pbp[f'{team[0]}_team_abbr']), 1, 0)
+        pbp['SA'] = np.where((pbp['event_type'].isin(['shot-on-goal','goal'])) & (pbp['event_team_abbr'] == pbp[f'{team[1]}_team_abbr']), 1, 0)
         pbp['FF'] = np.where((pbp['event_type'].isin(fenwick_events)) & (pbp['event_team_abbr'] == pbp[f'{team[0]}_team_abbr']), 1, 0)
         pbp['FA'] = np.where((pbp['event_type'].isin(fenwick_events)) & (pbp['event_team_abbr'] == pbp[f'{team[1]}_team_abbr']), 1, 0)
         pbp['CF'] = np.where((pbp['event_type'].isin(fenwick_events+['blocked-shot'])) & (pbp['event_team_abbr'] == pbp[f'{team[0]}_team_abbr']), 1, 0)
@@ -234,6 +249,8 @@ def calc_team(pbp,game_strength,second_group):
             FA=('FA', 'sum'),
             GF=('GF', 'sum'),
             GA=('GA', 'sum'),
+            SF=('SF','sum'),
+            SA=('SA','sum'),
             xGF=('xGF', 'sum'),
             xGA=('xGA', 'sum'),
             CF=('CF','sum'),
@@ -264,6 +281,8 @@ def calc_team(pbp,game_strength,second_group):
             FA=('FA', 'sum'),
             GF=('GF', 'sum'),
             GA=('GA', 'sum'),
+            SF=('SF','sum'),
+            SA=('SA','sum'),
             xGF=('xGF', 'sum'),
             xGA=('xGA', 'sum'),
             CF=('CF','sum'),
@@ -286,15 +305,18 @@ def calc_team(pbp,game_strength,second_group):
             RushAG=('RushAG','sum'),
     ).reset_index()
 
+    onice_stats['ShF%'] = onice_stats['GF']/onice_stats['SF']
     onice_stats['xGF/FF'] = onice_stats['xGF']/onice_stats['FF']
     onice_stats['GF/xGF'] = onice_stats['GF']/onice_stats['xGF']
     onice_stats['FshF%'] = onice_stats['GF']/onice_stats['FF']
+    onice_stats['ShA%'] = onice_stats['GA']/onice_stats['SA']
     onice_stats['xGA/FA'] = onice_stats['xGA']/onice_stats['FA']
     onice_stats['GA/xGA'] = onice_stats['GA']/onice_stats['xGA']
     onice_stats['FshA%'] = onice_stats['GA']/onice_stats['FA']
     onice_stats['PM%'] = onice_stats['Take']/(onice_stats['Give']+onice_stats['Take'])
     onice_stats['HF%'] = onice_stats['HF']/(onice_stats['HF']+onice_stats['HA'])
     onice_stats['PENL%'] = onice_stats['Draw']/(onice_stats['Draw']+onice_stats['Penl'])
+    onice_stats['GSAx'] = onice_stats['xGA']/onice_stats['GA']
 
     return onice_stats
 
@@ -313,6 +335,8 @@ def calc_goalie(pbp,game_strength,second_group):
         pbp['xGA'] = np.where(pbp['event_team_abbr'] == pbp[f'{team[1]}_team_abbr'], pbp['xG'], 0)
         pbp['GF'] = np.where((pbp['event_type'] == "goal") & (pbp['event_team_abbr'] == pbp[f'{team[0]}_team_abbr']), 1, 0)
         pbp['GA'] = np.where((pbp['event_type'] == "goal") & (pbp['event_team_abbr'] == pbp[f'{team[1]}_team_abbr']), 1, 0)
+        pbp['SF'] = np.where((pbp['event_type'].isin(['shot-on-goal','goal'])) & (pbp['event_team_abbr'] == pbp[f'{team[0]}_team_abbr']), 1, 0)
+        pbp['SA'] = np.where((pbp['event_type'].isin(['shot-on-goal','goal'])) & (pbp['event_team_abbr'] == pbp[f'{team[1]}_team_abbr']), 1, 0)
         pbp['FF'] = np.where((pbp['event_type'].isin(fenwick_events)) & (pbp['event_team_abbr'] == pbp[f'{team[0]}_team_abbr']), 1, 0)
         pbp['FA'] = np.where((pbp['event_type'].isin(fenwick_events)) & (pbp['event_team_abbr'] == pbp[f'{team[1]}_team_abbr']), 1, 0)
         pbp['CF'] = np.where((pbp['event_type'].isin(fenwick_events+['blocked-shot'])) & (pbp['event_team_abbr'] == pbp[f'{team[0]}_team_abbr']), 1, 0)
@@ -331,6 +355,8 @@ def calc_goalie(pbp,game_strength,second_group):
             FA=('FA', 'sum'),
             GF=('GF', 'sum'),
             GA=('GA', 'sum'),
+            SF=('SF', 'sum'),
+            SA=('SA', 'sum'),
             xGF=('xGF', 'sum'),
             xGA=('xGA', 'sum'),
             CF=('CF','sum'),
@@ -351,6 +377,8 @@ def calc_goalie(pbp,game_strength,second_group):
             FA=('FA', 'sum'),
             GF=('GF', 'sum'),
             GA=('GA', 'sum'),
+            SF=('SF', 'sum'),
+            SA=('SA', 'sum'),
             xGF=('xGF', 'sum'),
             xGA=('xGA', 'sum'),
             CF=('CF','sum'),
@@ -363,9 +391,11 @@ def calc_goalie(pbp,game_strength,second_group):
             RushAG=('RushAG','sum'),
     ).reset_index()
 
+    onice_stats['ShF%'] = onice_stats['GF']/onice_stats['SF']
     onice_stats['xGF/FF'] = onice_stats['xGF']/onice_stats['FF']
     onice_stats['GF/xGF'] = onice_stats['GF']/onice_stats['xGF']
     onice_stats['FshF%'] = onice_stats['GF']/onice_stats['FF']
+    onice_stats['ShA%'] = onice_stats['GA']/onice_stats['SA']
     onice_stats['xGA/FA'] = onice_stats['xGA']/onice_stats['FA']
     onice_stats['GA/xGA'] = onice_stats['GA']/onice_stats['xGA']
     onice_stats['FshA%'] = onice_stats['GA']/onice_stats['FA']

wsba_hockey/tools/scraping.py

@@ -533,6 +533,171 @@ def parse_html(info):
     #Return: parsed HTML pbp
     return data
 
+### ESPN SCRAPING FUNCTIONS ###
+def espn_game_id(date,away,home):
+    #Given a date formatted as YYYY-MM-DD and teams, return game id from ESPN schedule
+    date = date.replace("-","")
+
+    #Retreive data
+    api = f"https://site.api.espn.com/apis/site/v2/sports/hockey/nhl/scoreboard?dates={date}"
+    schedule = pd.json_normalize(rs.get(api).json()['events'])
+
+    #Create team abbreviation columns
+    schedule['away_team_abbr'] = schedule['shortName'].str[:3].str.strip(" ")
+    schedule['home_team_abbr'] = schedule['shortName'].str[-3:].str.strip(" ")
+    
+    #Modify team abbreviations as necessary
+    schedule = schedule.replace({
+        "LA":"LAK",
+        "NJ":"NJD",
+        "SJ":"SJS",
+        "TB":"TBL",
+    })
+
+    #Retreive game id
+    game_id = schedule.loc[(schedule['away_team_abbr']==away)&
+                           (schedule['home_team_abbr']==home),'id'].tolist()[0]
+
+    #Return: ESPN game id
+    return game_id
+
+def parse_espn(date,away,home):
+    #Given a date formatted as YYYY-MM-DD and teams, return game events
+    game_id = espn_game_id(date,away,home)
+    url = f'https://www.espn.com/nhl/playbyplay/_/gameId/{game_id}'
+    
+    #Code modified from Patrick Bacon
+
+    #Retreive game events as json
+    page = rs.get(url, headers={'User-Agent': 'Mozilla/5.0'}, timeout = 500)
+    soup = BeautifulSoup(page.content.decode('ISO-8859-1'), 'lxml', multi_valued_attributes = None)
+    json = json_lib.loads(str(soup).split('"playGrps":')[1].split(',"tms"')[0])
+
+    #DataFrame of time-related info for events
+    clock_df = pd.DataFrame()
+
+    for period in range(0, len(json)):
+        clock_df = clock_df._append(pd.DataFrame(json[period]))
+
+    clock_df = clock_df[~pd.isna(clock_df.clock)]
+
+    # Needed to add .split(',"st":3')[0] for playoffs
+
+    #DataFrame of coordinates for events
+    coords_df = pd.DataFrame(json_lib.loads(str(soup).split('plays":')[1].split(',"st":1')[0].split(',"st":2')[0].split(',"st":3')[0]))
+
+    clock_df = clock_df.assign(
+        clock = clock_df.clock.apply(lambda x: x['displayValue'])
+    )
+
+    coords_df = coords_df.assign(
+        coords_x = coords_df[~pd.isna(coords_df.coordinate)].coordinate.apply(lambda x: x['x']).astype(int),
+        coords_y = coords_df[~pd.isna(coords_df.coordinate)].coordinate.apply(lambda y: y['y']).astype(int),
+    )
+
+    #Combine
+    espn_events = coords_df.merge(clock_df.loc[:, ['id', 'clock']])
+
+    espn_events = espn_events.assign(
+        period = espn_events['period'].apply(lambda x: x['number']),
+        minutes = espn_events['clock'].str.split(':').apply(lambda x: x[0]).astype(int),
+        seconds = espn_events['clock'].str.split(':').apply(lambda x: x[1]).astype(int),
+        event_type = espn_events['type'].apply(lambda x: x['txt'])
+    )
+
+    espn_events = espn_events.assign(coords_x = np.where((pd.isna(espn_events.coords_x)) & (pd.isna(espn_events.coords_y)) &
+                (espn_events.event_type=='Face Off'), 0, espn_events.coords_x
+    ),
+                      coords_y = np.where((pd.isna(espn_events.coords_x)) & (pd.isna(espn_events.coords_y)) &
+                (espn_events.event_type=='Face Off'), 0, espn_events.coords_y))
+
+    espn_events = espn_events[(~pd.isna(espn_events.coords_x)) & (~pd.isna(espn_events.coords_y))]
+
+    espn_events = espn_events.assign(
+        coords_x = espn_events.coords_x.astype(int),
+        coords_y = espn_events.coords_y.astype(int)
+    )
+    
+    #Rename events
+    #The turnover event includes just one player in the event information, meaning takeaways will have no coordinates for play-by-plays created by ESPN scraping
+    espn_events['event_type'] = espn_events['event_type'].replace({
+        "Face Off":'faceoff',
+        "Hit":'hit',
+        "Shot":'shot-on-goal',
+        "Missed":'missed-shot',
+        "Blocked":'blocked-shot',
+        "Goal":'goal',
+        "Delayed Penalty":'delayed-penalty',
+        "Penalty":'penalty',
+    })
+
+    #Period time adjustments (only 'seconds_elapsed' is included in the resulting data)
+    espn_events['period_time_simple'] = espn_events['clock'].str.replace(":","",regex=True)
+    espn_events['period_seconds_elapsed'] = np.where(espn_events['period_time_simple'].str.len()==3,
+                                            ((espn_events['period_time_simple'].str[0].astype(int)*60)+espn_events['period_time_simple'].str[-2:].astype(int)),
+                                            ((espn_events['period_time_simple'].str[0:2].astype(int)*60)+espn_events['period_time_simple'].str[-2:].astype(int)))
+    espn_events['seconds_elapsed'] = ((espn_events['period']-1)*1200)+espn_events['period_seconds_elapsed']
+
+    espn_events = espn_events.rename(columns = {'text':'description'})
+
+    #Add event team
+    espn_events['event_team_abbr'] = espn_events['homeAway'].replace({
+        "away":away,
+        "home":home
+    })
+
+    #Some games (mostly preseason and all star games) do not include coordinates.  
+    try:
+        espn_events['x_fixed'] = abs(espn_events['coords_x'])
+        espn_events['y_fixed'] = np.where(espn_events['coords_x']<0,-espn_events['coords_y'],espn_events['coords_y'])
+        espn_events['x_adj'] = np.where(espn_events['homeAway']=="home",espn_events['x_fixed'],-espn_events['x_fixed'])
+        espn_events['y_adj'] = np.where(espn_events['homeAway']=="home",espn_events['y_fixed'],-espn_events['y_fixed'])
+        espn_events['event_distance'] = np.sqrt(((89 - espn_events['x_fixed'])**2) + (espn_events['y_fixed']**2))
+        espn_events['event_angle'] = np.degrees(np.arctan2(abs(espn_events['y_fixed']), abs(89 - espn_events['x_fixed'])))
+    except TypeError:
+        print(f"No coordinates found for ESPN game...")
+    
+        espn_events['x_fixed'] = np.nan
+        espn_events['y_fixed'] = np.nan
+        espn_events['x_adj'] = np.nan
+        espn_events['y_adj'] = np.nan
+        espn_events['event_distance'] = np.nan
+        espn_events['event_angle'] = np.nan
+
+    #Assign score and fenwick for each event
+    fenwick_events = ['missed-shot','shot-on-goal','goal']
+    ag = 0
+    ags = []
+    hg = 0
+    hgs = []
+
+    af = 0
+    afs = []
+    hf = 0
+    hfs = []
+    for event,team in zip(list(espn_events['event_type']),list(espn_events['homeAway'])):
+        if event in fenwick_events:
+            if team == "home":
+                hf += 1
+                if event == 'goal':
+                    hg += 1
+            else:
+                af += 1
+                if event == 'goal':
+                    ag += 1
+       
+        ags.append(ag)
+        hgs.append(hg)
+        afs.append(af)
+        hfs.append(hf)
+
+    espn_events['away_score'] = ags
+    espn_events['home_score'] = hgs
+    espn_events['away_fenwick'] = afs
+    espn_events['home_fenwick'] = hfs
+    #Return: play-by-play events in supplied game from ESPN
+    return espn_events
+
 def assign_target(data):
     #Assign target number to plays to assist with merging
 
@@ -554,12 +719,11 @@ def combine_pbp(info,sources):
     #Route data combining - json if season is after 2009-2010:
     if str(info['season']) in ['20052006','20062007','20072008','20082009','20092010']:
         #ESPN x HTML
-        #espn_pbp = parse_espn(str(info['game_date']),info['away_team_abbr'],info['home_team_abbr']).rename(columns={'coords_x':'x',"coords_y":'y'}).sort_values(['period','seconds_elapsed']).reset_index()
-        #merge_col = ['period','seconds_elapsed','event_type','event_team_abbr']
+        espn_pbp = parse_espn(str(info['game_date']),info['away_team_abbr'],info['home_team_abbr']).rename(columns={'coords_x':'x',"coords_y":'y'}).sort_values(['period','seconds_elapsed']).reset_index()
+        merge_col = ['period','seconds_elapsed','event_type','event_team_abbr']
 
         #Merge pbp
-        #df = pd.merge(html_pbp,espn_pbp,how='left',on=merge_col)
-        print('In-repair, please try again later...')
+        df = pd.merge(html_pbp,espn_pbp,how='left',on=merge_col)
 
     else:
         #JSON x HTML

wsba_hockey/workspace.py

@@ -6,7 +6,9 @@ import numpy as np
 
 season_load = wsba.repo_load_seasons()
 
-select = season_load[9:17]
+select = season_load[0:3]
+
+data.pbp(select)
 
 #pbp = data.load_pbp_db(select)
 
@@ -26,26 +28,4 @@ select = season_load[9:17]
 #data.fix_names(['skater','goalie'],select)
 
 ## DATA EXPORT ##
-#data.push_to_sheet(select,['skaters','team','info'])
-
-wsba.nhl_scrape_game(['2024020008'],remove=[]).to_csv('wtfwhy.csv',index=False)
-
-pbp = pd.read_parquet('pbp/parquet/nhl_pbp_20242025.parquet')
-helle = pbp.loc[pbp['event_goalie_id']==8476945,
-                ['game_id','period','seconds_elapsed',
-                 'strength_state','event_type','description',
-                 'event_goalie_id','x','y','xG']]
-mp = pd.read_csv('shots_2024.csv')
-goalie = mp.loc[mp['goalieIdForShot']==8476945,
-                ['game_id','period','time','event','goalieIdForShot',
-                 'xCord','yCord','xGoal']].replace({
-                     'SHOT':'shot-on-goal',
-                     'MISS':'missed-shot',
-                     'GOAL':'goal'
-                 })
-
-helle.to_csv('hellebuyck.csv',index=False)
-helle['game_id'] = helle['game_id'].astype(str)
-goalie['game_id'] = ('20240'+goalie['game_id'].astype(str))
-pd.merge(helle,goalie,how='left',left_on=['game_id','period','seconds_elapsed','event_type','x','y'],right_on=['game_id','period','time','event','xCord','yCord']).to_csv('test.csv',index=False)
-
+#data.push_to_sheet(select,['skaters','team','info'])