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

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

@@ -0,0 +1,103 @@
+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 = {
+            'team':['BOS'],
+            'season':['20222023'],
+            '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()
+        else:
+            rink = wsba_plt.wsba_rink()
+
+            try:
+                for_plot = wsba_plt.heatmap(df,team=query['team'][0],events=['missed-shot','shot-on-goal','goal'],strengths=query['strength_state'],onice='for')
+                against_plot = wsba_plt.heatmap(df,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)
+
+                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'{team} On-Ice xG at {strengths}; {season}-{season+1}, {span}',
+                        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/team_heatmaps/plot.py

@@ -0,0 +1,95 @@
+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,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'])
+        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')
+    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':
+            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['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
+    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

wsba_hockey/evidence/weakside-breakout/wsba_nhl_apps/wsba_nhl_apps/team_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://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/flask/app.py

@@ -0,0 +1,77 @@
+from flask import Flask, render_template, request, redirect
+from flask_sqlalchemy import SQLAlchemy
+import pandas as pd
+
+app = Flask(__name__)
+
+#Globals
+seasons = [
+    '20102011',
+    '20112012',
+    '20122013',
+    '20132014',
+    '20142015',
+    '20152016',
+    '20162017',
+    '20172018',
+    '20182019',
+    '20192020',
+    '20202021',
+    '20212022', 
+    '20222023',
+    '20232024',
+    '20242025'
+]
+
+#Generate pages
+@app.route("/")
+def index():
+    return render_template("index.html")
+
+@app.route("/about/about")
+def about():
+    return render_template("about/about.html")
+
+@app.route("/about/glossary")
+def glossary():
+    return render_template("about/glossary.html")
+
+@app.route("/about/goal_impact")
+def goal_impact():
+    return render_template("about/goal_impact.html")
+
+@app.route("/about/resources")
+def resources():
+    return render_template("about/resources.html")
+
+@app.route("/about/xg_model")
+def xg_model():
+    return render_template("about/xg_model.html")
+
+@app.route("/games/schedule")
+def schedule():
+    return render_template("games/schedule.html")
+
+@app.route("/games/game_metrics")
+def pbp_viewer():
+    return render_template("games/game_metrics.html")
+
+@app.route("/players/skater_stats", methods=["GET", "POST"])
+def skater_stats():
+    filters = {}
+    for filter in ['season','span','strength','position','display','type','min_age','min_toi']:
+        print(request.args.get(filter))
+        filters.update({filter:request.args.get(filter)})
+
+    return render_template("players/skater_stats.html")
+
+@app.route("/players/goalie_stats")
+def goalie_stats():
+    return render_template("players/goalie_stats.html")
+
+@app.route("/players/team_stats")
+def team_stats():
+    return render_template("players/team_stats.html")
+
+if __name__ == "__main__":
+    app.run()

wsba_hockey/tools/plotting.py

@@ -1,3 +1,4 @@
+import os
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd

wsba_hockey/tools/scraping.py

@@ -28,7 +28,7 @@ def get_col():
     return [
         'season','season_type','game_id','game_date',"start_time","venue","venue_location",
         'away_team_abbr','home_team_abbr','event_num','period','period_type',
-        'seconds_elapsed',"strength_state","strength_state_venue","home_team_defending_side",
+        'seconds_elapsed','period_time','game_time',"strength_state","strength_state_venue","home_team_defending_side",
         "event_type_code","event_type","description","event_reason",
         "penalty_type","penalty_duration","penalty_attribution",
         "event_team_abbr","event_team_venue",
@@ -984,7 +984,11 @@ def combine_data(info,sources):
         df[f'{venue}_corsi'] = ((df['event_team_venue']==venue)&(df['event_type'].isin(['blocked-shot','missed-shot','shot-on-goal','goal']))).cumsum()
         df[f'{venue}_fenwick'] = ((df['event_team_venue']==venue)&(df['event_type'].isin(['missed-shot','shot-on-goal','goal']))).cumsum()
         df[f'{venue}_penalties'] = ((df['event_team_venue']==venue)&(df['event_type']=='penalty')).cumsum()
-       
+    
+    #Add time adjustments
+    df['period_time'] = np.trunc((df['seconds_elapsed']-((df['period']-1)*1200))/60).astype(str).str.replace('.0','')+":"+(df['seconds_elapsed'] % 60).astype(str).str.pad(2,'left','0')
+    df['game_time'] = np.trunc(df['seconds_elapsed']/60).astype(str).str.replace('.0','')+":"+(df['seconds_elapsed'] % 60).astype(str).str.pad(2,'left','0')
+
     #Forward fill as necessary
     cols = ['period_type','home_team_defending_side','away_coach','home_coach']
     for col in cols:

wsba_hockey/tools/xg_model.py

@@ -118,7 +118,7 @@ def fix_players(pbp):
 
 def prep_xG_data(data):
     #Prep data for xG training and calculation
-    data = fix_players(data)
+    #data = fix_players(data)
 
     #Informal groupby
     data = data.sort_values(by=['season','game_id','period','seconds_elapsed','event_num'])

wsba_hockey/workspace.py

@@ -6,30 +6,46 @@ import numpy as np
 
 season_load = wsba.repo_load_seasons()
 
-select = season_load[3:18]
-
-#data.pbp(select)
-#data.pbp_db(select)
+select = season_load[9:17]
 
 #pbp = data.load_pbp_db(select)
 
 #wsba.wsba_xG(pbp,hypertune=True,train=True,train_runs=30,cv_runs=30)
+#select = season_load[3:18]
 #for season in select:
 #    wsba.nhl_apply_xG(data.load_pbp([season])).to_parquet(f'pbp/parquet/nhl_pbp_{season}.parquet',index=False)
 #data.pbp_db(select)
-test = pd.read_parquet('backblaze_pbp/20242025.parquet')
-test.loc[(test['event_goalie_id']==8476945)].to_csv('Hellebuyck.csv',index=False)
 
-mp = pd.read_csv('shots_2024.csv')
-mp.loc[(mp['goalieIdForShot']==8476945)].to_csv('mfreally.csv',index=False)
+#test = pd.read_parquet('aws_pbp/20242025.parquet')
 #wsba.roc_auc_curve(test,'tools/xg_model/wsba_xg.joblib')
 #wsba.feature_importance('tools/xg_model/wsba_xg.joblib')
 #wsba.reliability(test,'tools/xg_model/wsba_xg.joblib')
 
-## UPLOAD TO BACKBLAZE ##
-
-#data.stats(['goalie'],select)
-#data.game_log(['goalie'],select)
+#data.build_stats(['skater','team','goalie'],select)
+#data.game_log(['skater','goalie'],select)
+#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)
+