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

wsba_hockey/data_pipelines.py

@@ -0,0 +1,183 @@
+import numpy as np
+import pandas as pd
+import wsba_main as wsba
+import numpy as np
+from datetime import datetime
+from gspread_pandas import Spread
+import matplotlib.pyplot as plt
+from scipy import stats
+
+### DATA PIPELINES ###
+
+def pbp(seasons):
+    for season in seasons:
+        errors=[]
+        for season in seasons:
+            data = wsba.nhl_scrape_season(season,remove=[],local=True,sources=True,errors=True)
+            errors.append(data['errors'])
+            data['pbp'].to_csv(f'pbp/nhl_pbp_{season}.csv',index=False)
+            pd.read_csv(f'pbp/nhl_pbp_{season}.csv').to_parquet(f'pbp/parquet/nhl_pbp_{season}.parquet',index=False)
+        print(f'Errors: {errors}')
+
+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)
+
+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])
+
+def stats(arg,seasons):
+    #Stats building
+    for group in arg:
+        for season in seasons:
+            pbp = pd.read_parquet(f'pbp/parquet/nhl_pbp_{season}.parquet')
+            strengths = pbp.loc[~(pbp['strength_state'].isin(['5v5','5v4','4v5'])),'strength_state'].drop_duplicates().to_list()
+            dfs = []
+            for strength in [['5v5'],['5v4'],['4v5'],strengths,'all']:
+                for season_type in [[2],[3]]:
+                    data = wsba.nhl_calculate_stats(pbp,group,season_type,strength,shot_impact=True)
+                    if strength != 'all':
+                        if len(strength) > 1:
+                            data['Strength'] = 'Other'
+                        else:
+                            data['Strength'] = strength[0]
+                    else:
+                        data['Strength'] = 'All'
+                    data['Span'] = season_type[0]
+                    dfs.append(data)
+            stat = pd.concat(dfs)
+            stat.to_csv(f'stats/{group}/wsba_nhl_{season}_{group}.csv',index=False)
+    
+def game_log(arg,seasons):
+    #Stats building
+    for group in arg:
+        for season in seasons:
+            pbp = pd.read_parquet(f'pbp/parquet/nhl_pbp_{season}.parquet')
+            strengths = pbp.loc[~(pbp['strength_state'].isin(['5v5','5v4','4v5'])),'strength_state'].drop_duplicates().to_list()
+            dfs = []
+            for strength in [['5v5'],['5v4'],['4v5'],strengths,'all']:
+                for season_type in [[2],[3]]:
+                    data = wsba.nhl_calculate_stats(pbp,group,season_type,strength,split_game=True,shot_impact=False)
+                    if strength != 'all':
+                        if len(strength) > 1:
+                            data['Strength'] = 'Other'
+                        else:
+                            data['Strength'] = strength[0]
+                    else:
+                        data['Strength'] = 'All'
+                    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)
+
+def push_to_sheet(seasons, types = ['skaters','team','goalie','info'], msg = 'Data Update'):
+    spread = Spread('WSBA - NHL 5v5 Shooting Metrics Public v1.0')
+
+    if 'skaters' in types:
+        #Tables
+        skater = pd.concat([pd.read_csv(f'stats/skater/wsba_nhl_{season}_skater.csv') for season in seasons])
+        skater = skater.loc[(skater['Strength']=='5v5')&(skater['Span']==2)]
+
+        spread.df_to_sheet(skater,index=False,sheet='Skaters DB')
+    
+    if 'team' in types:
+        team = pd.concat([pd.read_csv(f'stats/team/wsba_nhl_{season}_team.csv') for season in seasons])
+        team = team.loc[(team['Strength']=='5v5')&(team['Span']==2)]
+
+        spread.df_to_sheet(team,index=False,sheet='Teams DB')
+
+    if 'goalie' in types:
+        goalie = pd.concat([pd.read_csv(f'stats/skater/wsba_nhl_{season}_goalie.csv') for season in seasons])
+        goalie = goalie.loc[(goalie['Strength']=='5v5')&(goalie['Span']==2)]
+
+        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')
+
+        spread.df_to_sheet(team_info,index=False,sheet='Team Info')
+        spread.df_to_sheet(country,index=False,sheet='Country Info')   
+        
+    #if 'schedule' in types:
+    #    schedule = pd.read_csv('schedule/schedule.csv')
+    #
+    #    spread.df_to_sheet(schedule,index=False,sheet='Schedule')
+
+    log = spread.sheet_to_df(0,1,2,sheet='Update Log')
+    update = pd.DataFrame({'Date/Time (US-Central)':[datetime.now()],
+                           'Change':[msg]})
+
+    spread.df_to_sheet(pd.concat([log,update]),index=False,start='A2',sheet='Update Log')
+
+    print('Done.')
+
+def compare_xG(seasons):
+    load_1 = pd.concat([pd.read_csv(f'stats/skater/wsba_nhl_{season}_skater.csv') for season in seasons])
+    load_2 = pd.read_csv('stats/moneypuck/moneypuck.csv')
+
+    dfs = []
+    for strength in [('5v5','5on5'),('5v4','5on4'),('4v5','4on5'),('Other','other'),('All','all')]:  
+        df = load_1
+        mp = load_2
+
+        df = df.loc[(df['Span']==2)&(df['Strength']==strength[0])][['ID','Season','xGi','Gi']].replace({
+            20162017:2016,
+            20172018:2017,
+            20182019:2018,
+            20192020:2019,
+            20202021:2020,
+            20212022:2021,
+            20222023:2022,
+            20232024:2023
+        })
+        mp = mp.loc[(mp['situation'])==strength[1]][['playerId','season','I_F_xGoals','I_F_goals']].rename(columns={'playerId':'ID','season':'Season','I_F_xGoals':'ixG','I_F_goals':'G'})
+
+        merge = pd.merge(df,mp,how='left')
+        merge = merge.dropna()
+
+        x = merge['xGi']
+        y = merge['ixG']
+
+        r,p = stats.pearsonr(x,y)
+        plt.scatter(x,y,label=f'r = {r:.4f}')
+        plt.title(f'WSBA xG vs MoneyPuck xG (2016-17 to 2023-24 in {strength[0]} situations)')
+        plt.xlabel('WSBA xG')
+        plt.ylabel('MoneyPuck xG')
+        plt.legend(loc="lower right")
+        plt.savefig(f'tools/xg_model/metrics/moneypuck/wsba_vs_moneypuck_{strength[0]}.png')
+        plt.close()
+        
+        for xg,model in [(df,'WSBA'),(mp,'MoneyPuck')]:
+            xg = xg.rename(columns={'xGi':'ixG','Gi':'G'})
+
+            x = xg['ixG']
+            y = xg['G']
+
+            r,p = stats.pearsonr(x,y)
+            plt.scatter(x,y,label=f'r = {r:.4f}')
+            plt.title(f'{model} xG vs Goals (2016-17 to 2023-24 in {strength[0]} situations)')
+            plt.xlabel(f'{model}')
+            plt.ylabel('Goals')
+            plt.legend(loc="lower right")
+            plt.savefig(f'tools/xg_model/metrics/predict_power/{model}_predict_power_{strength[0]}.png')
+            plt.close()
+
+        dfs.append(pd.DataFrame([
+            {   'Strength':strength[0],
+                'WSBA G-xG':np.mean(df['Gi']-df['xGi']),
+                'MoneyPuck G-xG':np.mean(mp['G']-mp['ixG'])
+            }
+            ]
+        ))
+        
+        compare = pd.concat(dfs)
+        compare['Compare'] = np.where(abs(compare['WSBA G-xG'])<abs(compare['MoneyPuck G-xG']),'WSBA','MoneyPuck')
+        compare.to_csv('tools/xg_model/metrics/predict_power/wsba_vs_moneypuck_predict_power.csv',index=False)

wsba_hockey/evidence/weakside-breakout/node_modules/duckdb/vendor.py

@@ -0,0 +1,146 @@
+import os
+import sys
+import json
+import pickle
+import argparse
+
+parser = argparse.ArgumentParser(description='Inlines DuckDB Sources')
+
+parser.add_argument('--duckdb', action='store',
+                    help='Path to the DuckDB Version to be vendored in', required=True, type=str)
+
+
+
+args = parser.parse_args()
+
+
+# list of extensions to bundle
+extensions = ['parquet', 'icu', 'json']
+
+# path to target
+basedir = os.getcwd()
+target_dir = os.path.join(basedir, 'src', 'duckdb')
+gyp_in = os.path.join(basedir, 'binding.gyp.in')
+gyp_out = os.path.join(basedir, 'binding.gyp')
+cache_file = os.path.join(basedir, 'filelist.cache')
+
+# path to package_build.py
+os.chdir(os.path.join(args.duckdb))
+scripts_dir = 'scripts'
+
+sys.path.append(scripts_dir)
+import package_build
+
+defines = ['DUCKDB_EXTENSION_{}_LINKED'.format(ext.upper()) for ext in extensions]
+
+# Autoloading is on by default for node distributions
+defines.extend(['DUCKDB_EXTENSION_AUTOLOAD_DEFAULT=1', 'DUCKDB_EXTENSION_AUTOINSTALL_DEFAULT=1'])
+defines.extend(['NDEBUG'])
+
+if os.environ.get('DUCKDB_NODE_BUILD_CACHE') == '1' and os.path.isfile(cache_file):
+    with open(cache_file, 'rb') as f:
+        cache = pickle.load(f)
+    source_list = cache['source_list']
+    include_list = cache['include_list']
+    libraries = cache['libraries']
+    windows_options = cache['windows_options']
+    cflags = cache['cflags']
+elif 'DUCKDB_NODE_BINDIR' in os.environ:
+
+    def find_library_path(libdir, libname):
+        flist = os.listdir(libdir)
+        for fname in flist:
+            fpath = os.path.join(libdir, fname)
+            if os.path.isfile(fpath) and package_build.file_is_lib(fname, libname):
+                return fpath
+        raise Exception(f"Failed to find library {libname} in {libdir}")
+
+    # existing build
+    existing_duckdb_dir = os.environ['DUCKDB_NODE_BINDIR']
+    cflags = os.environ['DUCKDB_NODE_CFLAGS']
+    libraries = os.environ['DUCKDB_NODE_LIBS'].split(' ')
+
+    include_directories = [os.path.join('..', '..', include) for include in package_build.third_party_includes()]
+    include_list = package_build.includes(extensions)
+
+    result_libraries = package_build.get_libraries(existing_duckdb_dir, libraries, extensions)
+    libraries = []
+    for libdir, libname in result_libraries:
+        if libdir is None:
+            continue
+        libraries.append(find_library_path(libdir, libname))
+
+    source_list = []
+    cflags = []
+    windows_options = []
+    if os.name == 'nt':
+        windows_options = [x for x in os.environ['DUCKDB_NODE_CFLAGS'].split(' ') if x.startswith('/')]
+    else:
+        if '-g' in os.environ['DUCKDB_NODE_CFLAGS']:
+            cflags += ['-g']
+        if '-O0' in os.environ['DUCKDB_NODE_CFLAGS']:
+            cflags += ['-O0']
+
+    if 'DUCKDB_NODE_BUILD_CACHE' in os.environ:
+        cache = {
+            'source_list': source_list,
+            'include_list': include_list,
+            'libraries': libraries,
+            'cflags': cflags,
+            'windows_options': windows_options,
+        }
+        with open(cache_file, 'wb+') as f:
+            pickle.dump(cache, f)
+else:
+    # fresh build - copy over all of the files
+    (source_list, include_list, original_sources) = package_build.build_package(target_dir, extensions, False)
+
+    # # the list of all source files (.cpp files) that have been copied into the `duckdb_source_copy` directory
+    # print(source_list)
+    # # the list of all include files
+    # print(include_list)
+    source_list = [os.path.relpath(x, basedir) if os.path.isabs(x) else os.path.join('src', x) for x in source_list]
+    include_list = [os.path.join('src', 'duckdb', x) for x in include_list]
+    libraries = []
+    windows_options = ['/GR']
+    cflags = ['-frtti']
+
+
+def sanitize_path(x):
+    return x.replace('\\', '/')
+
+
+source_list = [sanitize_path(x) for x in source_list]
+include_list = [sanitize_path(x) for x in include_list]
+libraries = [sanitize_path(x) for x in libraries]
+
+with open(gyp_in, 'r') as f:
+    input_json = json.load(f)
+
+
+def replace_entries(node, replacement_map):
+    if type(node) == type([]):
+        for key in replacement_map.keys():
+            if key in node:
+                node.remove(key)
+                node += replacement_map[key]
+        for entry in node:
+            if type(entry) == type([]) or type(entry) == type({}):
+                replace_entries(entry, replacement_map)
+    if type(node) == type({}):
+        for key in node.keys():
+            replace_entries(node[key], replacement_map)
+
+
+replacement_map = {}
+replacement_map['${SOURCE_FILES}'] = source_list
+replacement_map['${INCLUDE_FILES}'] = include_list
+replacement_map['${DEFINES}'] = defines
+replacement_map['${LIBRARY_FILES}'] = libraries
+replacement_map['${CFLAGS}'] = cflags
+replacement_map['${WINDOWS_OPTIONS}'] = windows_options
+
+replace_entries(input_json, replacement_map)
+
+with open(gyp_out, 'w+') as f:
+    json.dump(input_json, f, indent=4, separators=(", ", ": "))

wsba_hockey/evidence/weakside-breakout/node_modules/flatted/python/flatted.py

@@ -0,0 +1,149 @@
+# ISC License
+#
+# Copyright (c) 2018-2021, Andrea Giammarchi, @WebReflection
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+# AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+# LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+# OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+# PERFORMANCE OF THIS SOFTWARE.
+
+import json as _json
+
+class _Known:
+    def __init__(self):
+        self.key = []
+        self.value = []
+
+class _String:
+    def __init__(self, value):
+        self.value = value
+
+
+def _array_keys(value):
+    keys = []
+    i = 0
+    for _ in value:
+        keys.append(i)
+        i += 1
+    return keys
+
+def _object_keys(value):
+    keys = []
+    for key in value:
+        keys.append(key)
+    return keys
+
+def _is_array(value):
+    return isinstance(value, list) or isinstance(value, tuple)
+
+def _is_object(value):
+    return isinstance(value, dict)
+
+def _is_string(value):
+    return isinstance(value, str)
+
+def _index(known, input, value):
+    input.append(value)
+    index = str(len(input) - 1)
+    known.key.append(value)
+    known.value.append(index)
+    return index
+
+def _loop(keys, input, known, output):
+    for key in keys:
+        value = output[key]
+        if isinstance(value, _String):
+            _ref(key, input[int(value.value)], input, known, output)
+
+    return output
+
+def _ref(key, value, input, known, output):
+    if _is_array(value) and not value in known:
+        known.append(value)
+        value = _loop(_array_keys(value), input, known, value)
+    elif _is_object(value) and not value in known:
+        known.append(value)
+        value = _loop(_object_keys(value), input, known, value)
+
+    output[key] = value
+
+def _relate(known, input, value):
+    if _is_string(value) or _is_array(value) or _is_object(value):
+        try:
+            return known.value[known.key.index(value)]
+        except:
+            return _index(known, input, value)
+
+    return value
+
+def _transform(known, input, value):
+    if _is_array(value):
+        output = []
+        for val in value:
+            output.append(_relate(known, input, val))
+        return output
+
+    if _is_object(value):
+        obj = {}
+        for key in value:
+            obj[key] = _relate(known, input, value[key])
+        return obj
+
+    return value
+
+def _wrap(value):
+    if _is_string(value):
+        return _String(value)
+
+    if _is_array(value):
+        i = 0
+        for val in value:
+            value[i] = _wrap(val)
+            i += 1
+
+    elif _is_object(value):
+        for key in value:
+            value[key] = _wrap(value[key])
+
+    return value
+
+def parse(value, *args, **kwargs):
+    json = _json.loads(value, *args, **kwargs)
+    wrapped = []
+    for value in json:
+        wrapped.append(_wrap(value))
+
+    input = []
+    for value in wrapped:
+        if isinstance(value, _String):
+            input.append(value.value)
+        else:
+            input.append(value)
+
+    value = input[0]
+
+    if _is_array(value):
+        return _loop(_array_keys(value), input, [value], value)
+
+    if _is_object(value):
+        return _loop(_object_keys(value), input, [value], value)
+
+    return value
+
+
+def stringify(value, *args, **kwargs):
+    known = _Known()
+    input = []
+    output = []
+    i = int(_index(known, input, value))
+    while i < len(input):
+        output.append(_transform(known, input, input[i]))
+        i += 1
+    return _json.dumps(output, *args, **kwargs)

wsba_hockey/evidence/weakside-breakout/node_modules/flatted/python/test.py

@@ -0,0 +1,63 @@
+from flatted import stringify as _stringify, parse
+
+def stringify(value):
+    return _stringify(value, separators=(',', ':'))
+
+assert stringify([None, None]) == '[[null,null]]'
+
+a = []
+o = {}
+
+assert stringify(a) == '[[]]'
+assert stringify(o) == '[{}]'
+
+a.append(a)
+o['o'] = o
+
+assert stringify(a) == '[["0"]]'
+assert stringify(o) == '[{"o":"0"}]'
+
+b = parse(stringify(a))
+assert isinstance(b, list) and b[0] == b
+
+a.append(1)
+a.append('two')
+a.append(True)
+o['one'] = 1
+o['two'] = 'two'
+o['three'] = True
+
+assert stringify(a) == '[["0",1,"1",true],"two"]'
+assert stringify(o) == '[{"o":"0","one":1,"two":"1","three":true},"two"]'
+
+a.append(o)
+o['a'] = a
+
+assert stringify(a) == '[["0",1,"1",true,"2"],"two",{"o":"2","one":1,"two":"1","three":true,"a":"0"}]'
+assert stringify(o) == '[{"o":"0","one":1,"two":"1","three":true,"a":"2"},"two",["2",1,"1",true,"0"]]'
+
+a.append({'test': 'OK'})
+a.append([1, 2, 3])
+
+o['test'] = {'test': 'OK'}
+o['array'] = [1, 2, 3]
+
+assert stringify(a) == '[["0",1,"1",true,"2","3","4"],"two",{"o":"2","one":1,"two":"1","three":true,"a":"0","test":"3","array":"4"},{"test":"5"},[1,2,3],"OK"]'
+assert stringify(o) == '[{"o":"0","one":1,"two":"1","three":true,"a":"2","test":"3","array":"4"},"two",["2",1,"1",true,"0","3","4"],{"test":"5"},[1,2,3],"OK"]'
+
+a2 = parse(stringify(a));
+o2 = parse(stringify(o));
+
+assert a2[0] == a2
+assert o2['o'] == o2
+
+assert a2[1] == 1 and a2[2] == 'two' and a2[3] == True and isinstance(a2[4], dict)
+assert a2[4] == a2[4]['o'] and a2 == a2[4]['o']['a']
+
+str = parse('[{"prop":"1","a":"2","b":"3"},{"value":123},["4","5"],{"e":"6","t":"7","p":4},{},{"b":"8"},"f",{"a":"9"},["10"],"sup",{"a":1,"d":2,"c":"7","z":"11","h":1},{"g":2,"a":"7","b":"12","f":6},{"r":4,"u":"7","c":5}]')
+assert str['b']['t']['a'] == 'sup' and str['a'][1]['b'][0]['c'] == str['b']['t']
+
+oo = parse('[{"a":"1","b":"0","c":"2"},{"aa":"3"},{"ca":"4","cb":"5","cc":"6","cd":"7","ce":"8","cf":"9"},{"aaa":"10"},{"caa":"4"},{"cba":"5"},{"cca":"2"},{"cda":"4"},"value2","value3","value1"]');
+assert oo['a']['aa']['aaa'] == 'value1' and oo == oo['b'] and oo['c']['ca']['caa'] == oo['c']['ca']
+
+print('OK')

wsba_hockey/evidence/weakside-breakout/node_modules/node-gyp/gyp/gyp_main.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009 Google Inc. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import os
+import sys
+import subprocess
+
+
+def IsCygwin():
+    # Function copied from pylib/gyp/common.py
+    try:
+        out = subprocess.Popen(
+            "uname", stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+        )
+        stdout, _ = out.communicate()
+        return "CYGWIN" in stdout.decode("utf-8")
+    except Exception:
+        return False
+
+
+def UnixifyPath(path):
+    try:
+        if not IsCygwin():
+            return path
+        out = subprocess.Popen(
+            ["cygpath", "-u", path], stdout=subprocess.PIPE, stderr=subprocess.STDOUT
+        )
+        stdout, _ = out.communicate()
+        return stdout.decode("utf-8")
+    except Exception:
+        return path
+
+
+# Make sure we're using the version of pylib in this repo, not one installed
+# elsewhere on the system. Also convert to Unix style path on Cygwin systems,
+# else the 'gyp' library will not be found
+path = UnixifyPath(sys.argv[0])
+sys.path.insert(0, os.path.join(os.path.dirname(path), "pylib"))
+import gyp  # noqa: E402
+
+if __name__ == "__main__":
+    sys.exit(gyp.script_main())