wsba-hockey 1.0.6__py3-none-any.whl → 1.1.1__py3-none-any.whl

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

wsba_hockey/evidence/weakside-breakout/wsba_nhl_apps/wsba_nhl_apps/goalie/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/heatmaps/app.py

@@ -44,7 +44,7 @@ def server(input, output, session):
         #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')
+        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})

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

@@ -13,6 +13,7 @@ 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.fillna(0)
     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'])
@@ -38,6 +39,7 @@ def heatmap(df,skater,team,events,strengths,onice):
     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')
+    df['strength_state_2'] = np.where(df['strength_state_2'].isin(['5v5','5v4','4v5']),df['strength_state_2'],'Other')
         
     if strengths != 'all':
         if onice == 'against':

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

@@ -222,7 +222,7 @@ def rink(setting = "full", vertical = False):
         )
 
     # Add logo
-    logo = Image.open(rs.get('https://f005.backblazeb2.com/file/weakside-breakout/utils/wsba.png',stream=True).raw)
+    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(

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

@@ -50,12 +50,12 @@ def server(input, output, session):
         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_1 = pd.read_parquet(f'https://weakside-breakout.s3.us-east-2.amazonaws.com/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')
+            df_1 = pd.read_parquet(f'https://weakside-breakout.s3.us-east-2.amazonaws.com/pbp/{season_1}.parquet')
+            df_2 = pd.read_parquet(f'https://weakside-breakout.s3.us-east-2.amazonaws.com/pbp/{season_2}.parquet')
         
         events = ['missed-shot','shot-on-goal','goal']
         team_xg = {}

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

@@ -12,6 +12,7 @@ def wsba_rink(setting='full', vertical=False):
 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.fillna(0)
     df = df.loc[(df['event_type'].isin(events))&(df['x_adj'].notna())&(df['y_adj'].notna())]
     if flip:
         if onice == 'for':
@@ -55,6 +56,7 @@ def heatmap_prep(df,team,events,strengths,onice,flip=False):
     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')
+    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'].isin(strengths)))]

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

@@ -222,7 +222,7 @@ def rink(setting = "full", vertical = False):
         )
 
     # Add logo
-    logo = Image.open(rs.get('https://f005.backblazeb2.com/file/weakside-breakout/utils/wsba.png',stream=True).raw)
+    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(