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

wsba_hockey/evidence/weakside-breakout/wsba_nhl_apps/wsba_nhl_apps/heatmaps/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://f005.backblazeb2.com/file/weakside-breakout/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

@@ -0,0 +1,145 @@
+import pandas as pd
+import plot as wsba_plt
+import numpy as np
+import plotly.graph_objects as go
+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_matchup"),
+)
+
+def server(input, output, session):
+    @output()
+    @render_widget
+    def plot_matchup():
+        #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
+        #If no input data is provided automatically provide a select skater and plot all 5v5 fenwick shots
+        defaults = {
+            'seasona':['20242025,20242025'],
+            'teama':['EDM,FLA'],
+            '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(',')
+
+        for i in range(2):
+            query[f'team_{i+1}'] = [query['teams'][i]]
+            query[f'season_{i+1}'] = [query['seasons'][i]]
+
+        print(query)
+        season_1 = query['season_1'][0]
+        season_2 = query['season_2'][0]
+        #Load appropriate dataframes
+        if season_1 == season_2:
+            df_1 = pd.read_parquet(f'https://f005.backblazeb2.com/file/weakside-breakout/pbp/{season_1}.parquet')
+            df_2 = df_1
+
+        else:
+            df_1 = pd.read_parquet(f'https://f005.backblazeb2.com/file/weakside-breakout/pbp/{season_1}.parquet')
+            df_2 = pd.read_parquet(f'https://f005.backblazeb2.com/file/weakside-breakout/pbp/{season_2}.parquet')
+        
+        events = ['missed-shot','shot-on-goal','goal']
+        team_xg = {}
+        for team, season, df, flip in [(query['team_1'][0],season_1,df_1,True),(query['team_2'][0],season_2,df_2,False)]:
+            #Prepare dataframe for plotting based on URL parameters
+            df = df.loc[(df['season'].astype(str) == season)&(df['season_type'].astype(str).isin(query['season_type']))].replace({np.nan: None})
+
+            team_xg.update({team:{'for':wsba_plt.heatmap_prep(df,team,events,query['strength_state'],'for',flip=flip),
+                                  'against':wsba_plt.heatmap_prep(df,team,events,query['strength_state'],'against',flip=flip)}})
+            
+        #Left is team_1 for vs team_2 against; Right is team_2 for vs team_1 against
+        left_diff = team_xg[query['team_1'][0]]['for']-team_xg[query['team_2'][0]]['against']
+        right_diff = team_xg[query['team_2'][0]]['for']-team_xg[query['team_1'][0]]['against']
+
+        rink = wsba_plt.wsba_rink()
+
+        for difference,x_min,x_max in [(left_diff,-100,0),(right_diff,0,100)]:
+            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
+                                    ))
+                )
+            for trace in fig.data:
+                rink.add_trace(trace)
+        
+        team_1 = query['team_1'][0]
+        team_2 = query['team_2'][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'{team_1} ({season_1}, {span}) vs {team_2} ({season_2}, {span}): xG at {strengths}',
+                        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
+                )
+
+app = App(app_ui, server)

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

@@ -0,0 +1,77 @@
+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_prep(df,team,events,strengths,onice,flip=False):
+    df['event_team_abbr_2'] = np.where(df['home_team_abbr']==df['event_team_abbr'],df['away_team_abbr'],df['home_team_abbr'])
+
+    df = df.loc[(df['event_type'].isin(events))&(df['x_adj'].notna())&(df['y_adj'].notna())]
+    if flip:
+        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'])
+            df = df.loc[(df['event_distance']>-89)&(df['x']>-89)&(df['empty_net']==0)]
+
+            x_min = -100
+            x_max = 0
+        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'].fillna(0))
+            df = df.loc[(df['event_distance']<=89)&(df['x']<=89)&(df['empty_net']==0)]
+
+            x_min = 0
+            x_max = 100
+    else:
+        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':
+        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['event_team_abbr']==team)]
+    else:
+        player_shots = df.loc[(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
+    
+    return difference