wsba-hockey 1.1.8__py3-none-any.whl → 1.2.0__py3-none-any.whl

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

@@ -1,103 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,245 +0,0 @@
-
-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

@@ -1,77 +0,0 @@
-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/utils/config.py

@@ -1,14 +0,0 @@
-"""
-Basic configurations
-"""
-
-# Directory where to save pages
-# When True assumes ~/hockey_scraper_data
-# Otherwise can take str to `existing` directory
-DOCS_DIR = False
-
-# Boolean that tells us whether or not we should re-scrape a given page if it's already saved
-RESCRAPE = False
-
-# Whether to log verbose errors to log file
-LOG = False

wsba_hockey/tools/utils/save_pages.py

@@ -1,133 +0,0 @@
-#
-#Saves the scraped docs so you don't have to re-scrape them every time you want to parse the docs. 
-#
-#\**** Don't mess with this unless you know what you're doing \****
-#
-import os
-import gzip
-
-
-def create_base_file_path(file_info):
-    """
-    Creates the base file path for a given file
-    
-    :param file_info: Dictionary containing the info on the file. Includes the name, season, file type, and the dir
-                      we want to deposit any data in.
-    
-    :return: path 
-    """
-    # Shitty fix for when you already have it saved but don't have nwhl folders
-    if 'nwhl' in file_info['type']:
-        if not os.path.isdir(os.path.join(file_info['dir'], 'docs', str(file_info['season']), file_info['type'])):
-            os.mkdir(os.path.join(file_info['dir'], 'docs', str(file_info['season']), file_info['type']))
-
-    return os.path.join(file_info['dir'], 'docs', str(file_info['season']), file_info['type'], file_info['name'] + ".txt")
-
-
-def is_compressed(file_info):
-    """
-    Check if stored file is compressed as we used to not save them as compressed.
-
-    :param file_info: Dictionary containing the info on the file. Includes the name, season, file type, and the dir
-                      we want to deposit any data in.
-    
-    return Boolean
-    """
-    return os.path.isfile(create_base_file_path(file_info) + ".gz")
-
-
-def create_dir_structure(dir_name):
-    """
-    Create the basic directory structure for docs_dir if not done yet.
-    Creates the docs and csvs subdir if it doesn't exist
-
-    :param dir_name: Name of dir to create
-
-    :return None
-    """
-    if not os.path.isdir(os.path.join(dir_name, 'docs')):
-        os.mkdir(os.path.join(dir_name, 'docs'))
-
-    if not os.path.isdir(os.path.join(dir_name, 'csvs')): 
-        os.mkdir(os.path.join(dir_name, 'csvs'))
-
-
-
-def create_season_dirs(file_info):
-    """
-    Creates the infrastructure to hold all the scraped docs for a season
-    
-    :param file_info: Dictionary containing the info on the file. Includes the name, season, file type, and the dir
-                      we want to deposit any data in.
-                        
-    :return: None
-    """
-    sub_folders = ["html_pbp", "json_pbp", "espn_pbp", "html_shifts_home", "html_shifts_away", 
-                   "json_shifts", "html_roster", "json_schedule", "espn_scoreboard"]
-
-    season_path = os.path.join(file_info['dir'], 'docs', str(file_info['season']))
-    os.mkdir(season_path)
-
-    for sub_f in sub_folders:
-        os.mkdir(os.path.join(season_path, sub_f))
-
-
-def check_file_exists(file_info):
-    """
-    Checks if the file exists. Also check if structure for holding scraped file exists to. If not, it creates it. 
-
-    :param file_info: Dictionary containing the info on the file. Includes the name, season, file type, and the dir
-                      we want to deposit any data in.
-
-    :return: Boolean - True if it exists
-    """
-    create_dir_structure(file_info['dir'])
-
-    # Check if the folder for the season for the given game was created yet...if not create it
-    if not os.path.isdir(os.path.join(file_info['dir'], 'docs', str(file_info['season']))):
-        create_season_dirs(file_info)
-
-    # May or may not be compressed due to file saved under older versions
-    non_compressed_file = os.path.isfile(create_base_file_path(file_info)) 
-    compressed_file = is_compressed(file_info)
-
-    return compressed_file or non_compressed_file
-
-
-def get_page(file_info):
-    """
-    Get the file so we don't need to re-scrape.
-
-    Try both compressed and non-compressed for backwards compatability issues (formerly non-compressed)
-
-    :param file_info: Dictionary containing the info on the file. Includes the name, season, file type, and the dir
-                      we want to deposit any data in.
-
-    :return: Response or None
-    """
-    base_file = create_base_file_path(file_info)
-
-    if is_compressed(file_info):
-        with gzip.open(base_file + ".gz", 'rb') as my_file:
-            return my_file.read().decode("utf-8").replace('\n', '')
-    else:
-        with open(base_file, 'r') as my_file:
-            return my_file.read().replace('\n', '')
-
-
-def save_page(page, file_info):
-    """
-    Save the page we just scraped.
-    
-    Note: It'll only get saved if the directory already exists!!!!!!. I'm not dealing with any fuck ups. That would 
-    involve checking if it's even a valid path and creating it. Make sure you get it right. 
-
-    :param page: File scraped
-    :param file_info: Dictionary containing the info on the file. Includes the name, season, file type, and the dir
-                      we want to deposit any data in.
-
-    :return: None
-    """
-    if file_info['dir'] and page is not None and page != '':
-        with gzip.open(create_base_file_path(file_info) + ".gz", 'wb') as file:
-            file.write(page.encode())