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

{wsba_hockey-1.1.9.dist-info → wsba_hockey-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wsba_hockey
-Version: 1.1.9
+Version: 1.2.0
 Summary: WeakSide Breakout's complete Python package of access to hockey data, primairly including the scraping of National Hockey League schedule, play-by-play, and shifts information.
 Author-email: Owen Singh <owenbksingh@gmail.com>
 Project-URL: Homepage, https://github.com/owensingh38/wsba_hockey/
@@ -28,30 +28,28 @@ import wsba_hockey as wsba
 ```
 
 ## ALL FEATURES
-### Note: Features yet included are marked with *
-
 
 ## SCRAPING
 ### NHL Play-by-Play (of any game frame up to a full season)
 #### Functions:
 
 ```python
-wsba.nhl_scrape_game(['2024020918'],split_shifts=False,remove=['game-end'])
-wsba.nhl_scrape_season('20242025',split_shifts=False,remove=['game-end'],local=True)
+wsba.nhl_scrape_game(2024020918,split_shifts=False,remove=['game-end'])
+wsba.nhl_scrape_season(20242025,split_shifts=False,remove=['game-end'],local=True)
 ```
 
 ### NHL Season Information
 
 ```python
-wsba.nhl_scrape_schedule('20242025')
-wsba.nhl_scrape_seasons_info(seasons=['20212022','20222023','20232024','20242025'])
+wsba.nhl_scrape_schedule(20242025)
+wsba.nhl_scrape_seasons_info(seasons=[20212022,20222023,20232024,20242025])
 wsba.nhl_scrape_standings(arg = '2024-03-20')
 ```
 
 ### NHL Rosters and Player Information
 
 ```python
-wsba.nhl_scrape_roster('20242025')
+wsba.nhl_scrape_roster(20242025)
 wsba.nhl_scrape_team_info()
 ```
 
@@ -66,7 +64,7 @@ wsba.nhl_scrape_prospects('BOS')
 ## DATA ANALYTICS
 ### Expected Goals
 ```python
-pbp = wsba.nhl_scrape_game(['2024020918'],split_shifts=False,remove=['game-end'])
+pbp = wsba.nhl_scrape_game(2024020918,split_shifts=False,remove=['game-end'])
 pbp = wsba.nhl_apply_xG(pbp)
 ```
 
@@ -74,15 +72,15 @@ pbp = wsba.nhl_apply_xG(pbp)
 
 ### Stat Aggregation
 ```python
-pbp = wsba.nhl_scrape_season('20232024',remove=[], local = True)
+pbp = wsba.nhl_scrape_season(20232024,remove=[], local = True)
 wsba.nhl_calculate_stats(pbp,'skater',[2],['5v5','4v4','3v3'],shot_impact = True)
 ```
 ### Shot Plotting (Plots, Heatmaps, etc.)
 ```python
 skater_dict = {
-    'Patrice Bergeron':['20212022','BOS']
+    'Patrice Bergeron':[20212022,'BOS']
 }
-pbp = wsba.nhl_scrape_season('20212022',remove=[], local = True)
+pbp = wsba.nhl_scrape_season(20212022,remove=[], local = True)
 
 wsba.nhl_plot_skaters_shots(pbp,skater_dict,['5v5'],onice='for',legend=True)
 wsba.nhl_plot_games(pbp,legend=True)
@@ -91,18 +89,21 @@ wsba.nhl_plot_games(pbp,legend=True)
 ## REPOSITORY 
 ### Past Season Play-by-Play
 ```python
-wsba.repo_load_pbp(seasons=['20212022','20222023','20232024','20242025'])
+wsba.repo_load_pbp(seasons=[20212022,20222023,20232024,20242025])
 ```
 ### Team Information
 ```python
 wsba.repo_load_teaminfo()
-wsba.repo_load_rosters(seasons=['20212022','20222023','20232024','20242025'])
+wsba.repo_load_rosters(seasons=[20212022,20222023,20232024,20242025])
 ```
 ### Schedule
 ```python
-wsba.repo_load_schedule(seasons=['20212022','20222023','20232024','20242025'])
+wsba.repo_load_schedule(seasons=[20212022,20222023,20232024,20242025])
 ```
 
+## DOCUMENTATION
+View full documentation here: [WSBA Hockey Package Documentation](https://owensingh38.github.io/wsba_hockey/)
+
 ## ACKNOWLEDGEMENTS AND CREDITS 
 ### Huge thanks to the following:
 Harry Shomer - Creator of the hockey_scraper package, which contains select utils functions within this package and otherwise inspires the creation of this package.

wsba_hockey-1.2.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+wsba_hockey/__init__.py,sha256=rXczecTEm4W8F9RbFmIttxpX9aqiq7PF5KNDLQVY35w,539
+wsba_hockey/wsba_main.py,sha256=ELWCYcXCKtKb8Ha_kKQ9_sBJsgk4_M2Y3pw45ZQJjsM,73567
+wsba_hockey/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wsba_hockey/tools/agg.py,sha256=OkIYd-ApvGVYe2JJLOI21jnDIN5LH8nkeH7eo0reWFI,23364
+wsba_hockey/tools/plotting.py,sha256=81hBaM7tcwUNB4-tovPn7QreOUz6B2NuI_SR4-djVSk,6029
+wsba_hockey/tools/scraping.py,sha256=6_GyF8o56fuijTosm4x4OSrvpL61ZygluK2A26XajqU,52246
+wsba_hockey/tools/xg_model.py,sha256=OqSvr1Er3zGaY6ZTBnuulBTPLO6CPhNk97SwpnkRD6M,18686
+wsba_hockey/tools/archive/old_scraping.py,sha256=hEjMI1RtfeZnf0RBiJFI38oXkLZ3WofeH5xqcF4pzgM,49585
+wsba_hockey/tools/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wsba_hockey/tools/utils/shared.py,sha256=KxeQVttGem73yncAlnuZvTclqpJpoerTKtLusRh5zsk,2472
+wsba_hockey-1.2.0.dist-info/licenses/LICENSE,sha256=Nr_Um1Pd5FQJTWWgm7maZArdtYMbDhzXYSwyJIZDGik,1114
+wsba_hockey-1.2.0.dist-info/METADATA,sha256=isZ9jsdKaJ0fSgtFNy65TUIyKeNbWX6pjekjzsYEgPk,3592
+wsba_hockey-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+wsba_hockey-1.2.0.dist-info/top_level.txt,sha256=acU7s3x-RZC1zGiqCOmO0g267iqCg34lzIfdmYxxGmQ,12
+wsba_hockey-1.2.0.dist-info/RECORD,,

wsba_hockey/api/api/index.py

@@ -1,162 +0,0 @@
-import pandas as pd
-import pyarrow.dataset as ds
-import numpy as np
-import requests as rs
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-from datetime import datetime
-import pytz
-import feedparser
-
-app = FastAPI()
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-@app.get("/")
-def read_root():
-    return {"WeakSide Breakout Analysis": "Welcome to the API!"}
-
-@app.get("/articles")
-def articles():
-    rss = 'https://wsba.substack.com/feed'
-    feed = feedparser.parse(rss)
-
-    output = {}
-    output['articles'] = []
-    
-    for entry in feed['entries']:
-        year = entry['published_parsed'][0]
-        month = entry['published_parsed'][1]
-        day = entry['published_parsed'][2]
-
-        date = f'{year}-{month:02}-{day:02}'
-
-        if len(entry['links']) > 0:
-            for link in entry['links']:
-                if 'image' in link['type']:
-                    image = link['href']
-                else:
-                    image = ''
-        else:
-            if 'image' in link['type']:
-                image = link['href']
-            else:
-                image = ''
-
-        output['articles'].append(
-            {
-                'title': entry['title'],
-                'summary': entry['summary'],
-                'link': entry['link'],
-                'guid': entry['id'].replace('https://wsba.substack.com/p/',''),
-                'author': entry['author'],
-                'published': {'datetime': entry['published'],
-                              'date': date},
-                'thumbnail': image,
-                'content': entry['content'][0]['value']
-            }
-        )
-
-    return output
-
-@app.get("/nhl/players/{player_id}")
-def player(player_id: int):
-    player = rs.get(f'https://api-web.nhle.com/v1/player/{player_id}/landing').json()
-
-    return player
-
-@app.get("/nhl/schedule/{date}")
-def schedule_info(date: str):
-    data = rs.get(f'https://api-web.nhle.com/v1/schedule/{date}').json()
-    
-    eastern = pytz.timezone('US/Eastern')
-    for game in data['gameWeek'][0]['games']:
-        game['startTimeEST'] = datetime.strptime(game['startTimeUTC'],'%Y-%m-%dT%H:%M:%SZ').replace(tzinfo=pytz.UTC).astimezone(eastern).strftime('%I:%M %p')
-
-    return data
-
-@app.get("/nhl/bracket/{season}")
-def schedule_info(season: int):
-    year = str(season)[4:8]
-    data = rs.get(f'https://api-web.nhle.com/v1/playoff-bracket/{year}').json()
-    
-    return data
-
-@app.get("/nhl/games/{game_id}")
-def pbp(game_id: int):
-    df = pd.read_csv(f'data/sources/20242025/{game_id}.csv')
-
-    df = df.fillna('')
-
-    team_data = pd.read_csv('https://weakside-breakout.s3.us-east-2.amazonaws.com/info/nhl_teaminfo.csv')[['triCode','seasonId','teamName.default','teamLogo','Primary Color','Secondary Color','WSBA']]
-
-    info = df[['season','season_type','game_id','game_date',
-                'venue','venue_location']].drop_duplicates().to_dict(orient='records')[0]
-    
-    info.update({'notice':'All data and materials are from the National Hockey League.'})
-
-    teams = {}
-    for team in ['away','home']:
-        df = pd.merge(df,team_data,how='left',left_on=[f'{team}_team_abbr','season'],right_on=['triCode','seasonId']).fillna('')
-        mod = '' if team == 'away' else '_y'
-        teams.update({team: df[[f'{team}_team_abbr'
-                                ,f'{team}_coach',
-                                f'teamName.default{mod}',
-                                f'teamLogo{mod}',
-                                f'Primary Color{mod}',
-                                f'Secondary Color{mod}',
-                                f'WSBA{mod}']].rename(columns={f'{team}_team_abbr':'team_abbr',f'{team}_coach':'coach',
-                                                         f'teamName.default{mod}':'team_name',
-                                                         f'teamLogo{mod}':'team_logo',
-                                                         f'Primary Color{mod}':'primary_color',
-                                                         f'Secondary Color{mod}':'secondary_color',
-                                                         f'WSBA{mod}':'WSBA'
-                                                         }).drop_duplicates().to_dict(orient='records')[0]})
-
-    play_col = [
-        'event_num','period','period_type',
-        '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",
-        'num_on', 'players_on','ids_on','num_off','players_off','ids_off','shift_type',
-        "event_player_1_name","event_player_2_name","event_player_3_name",
-        "event_player_1_id","event_player_2_id","event_player_3_id",
-        "event_player_1_pos","event_player_2_pos","event_player_3_pos",
-        "event_goalie_name","event_goalie_id",
-        "shot_type","zone_code","x","y","x_fixed","y_fixed","x_adj","y_adj",
-        "event_skaters","away_skaters","home_skaters",
-        "event_distance","event_angle","event_length","seconds_since_last",
-        "away_score","home_score", "away_fenwick", "home_fenwick",
-        "away_on_1","away_on_2","away_on_3","away_on_4","away_on_5","away_on_6","away_goalie",
-        "home_on_1","home_on_2","home_on_3","home_on_4","home_on_5","home_on_6","home_goalie",
-        "away_on_1_id","away_on_2_id","away_on_3_id","away_on_4_id","away_on_5_id","away_on_6_id","away_goalie_id",
-        "home_on_1_id","home_on_2_id","home_on_3_id","home_on_4_id","home_on_5_id","home_on_6_id","home_goalie_id",
-        "event_coach",'xG'
-    ]
-    
-    def sanitize(value):
-        if isinstance(value, (np.generic, np.ndarray)):
-            return value.item()
-        return value
-
-    plays = [
-        {k: sanitize(v) for k, v in row.items() if v != ''}
-        for row in df[[col for col in play_col if col in df.columns]].to_dict(orient='records')
-    ]
-
-    plays = [
-        {k: sanitize(v) for k, v in row.items() if v != ''}
-        for row in df[[col for col in play_col if col in df.columns]].to_dict(orient='records')
-    ]
-
-    return {'info': info,
-            'teams': teams,
-            'plays': plays
-        }

wsba_hockey/data_pipelines.py

@@ -1,247 +0,0 @@
-import os
-import numpy as np
-import pandas as pd
-import wsba_hockey.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=False,sources=True,errors=True)
-            errors.append(data['errors'])
-            data['pbp'].to_csv('temp.csv',index=False)
-            pd.read_csv('temp.csv').to_parquet(f'pbp/parquet/nhl_pbp_{season}.parquet',index=False)
-            os.remove('temp.csv')
-        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'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'aws_pbp/{season}.parquet') for season in seasons])
-
-def build_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)
-            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')
-
-    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('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')   
-        
-    #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

@@ -1,146 +0,0 @@
-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=(", ", ": "))