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

wsba_hockey/wsba_main.py

@@ -1,9 +1,10 @@
 import random
 import os
-import requests as rs
-import pandas as pd
 import asyncio
 import time
+import requests as rs
+import pandas as pd
+import matplotlib.pyplot as plt
 from typing import Literal, Union
 from datetime import datetime, timedelta, date
 from wsba_hockey.tools.scraping import *
@@ -33,7 +34,8 @@ SEASONS = [
     20212022,
     20222023,
     20232024,
-    20242025
+    20242025,
+    20252026
 ]
 
 CONVERT_SEASONS = {2007: 20072008, 
@@ -53,7 +55,28 @@ CONVERT_SEASONS = {2007: 20072008,
                    2021: 20212022, 
                    2022: 20222023, 
                    2023: 20232024, 
-                   2024: 20242025}
+                   2024: 20242025,
+                   2025: 20252026}
+
+SEASON_NAMES = {20072008: '2007-08', 
+                20082009: '2008-09',
+                20092010: '2009-10', 
+                20102011: '2010-11',
+                20112012: '2011-12', 
+                20122013: '2012-13',
+                20132014: '2013-14', 
+                20142015: '2014-15',
+                20152016: '2015-16', 
+                20162017: '2016-17',
+                20172018: '2017-18',
+                20182019: '2018-19', 
+                20192020: '2019-20',
+                20202021: '2020-21', 
+                20212022: '2021-22',
+                20222023: '2022-23', 
+                20232024: '2023-24',
+                20242025: '2024-25',
+                20252025: '2025-26'}
 
 CONVERT_TEAM_ABBR = {'L.A':'LAK',
                      'N.J':'NJD',
@@ -71,6 +94,7 @@ KNOWN_PROBS = {
     2008020259:'HTML data is completely missing for this game.',
     2008020409:'HTML data is completely missing for this game.',
     2008021077:'HTML data is completely missing for this game.',
+    2008030311:'Missing shifts data for game between Pittsburgh and Carolina',
     2009020081:'HTML pbp for this game between Pittsburgh and Carolina is missing all but the period start and first faceoff events, for some reason.',
     2009020658:'Missing shifts data for game between New York Islanders and Dallas.',
     2009020885:'Missing shifts data for game between Sharks and Blue Jackets.',
@@ -98,7 +122,7 @@ def nhl_scrape_game(game_ids:list[int], split_shifts:bool = False, remove:list[s
     Given a set of game_ids (NHL API), return complete play-by-play information as requested.
 
     Args:
-        game_ids (List[int] or ['random', int, int, int]):
+        game_ids (int or List[int] or ['random', int, int, int]):
             List of NHL game IDs to scrape or use ['random', n, start_year, end_year] to fetch n random games.
         split_shifts (bool, optional):
             If True, returns a dict with separate 'pbp' and 'shifts' DataFrames. Default is False.
@@ -121,10 +145,13 @@ def nhl_scrape_game(game_ids:list[int], split_shifts:bool = False, remove:list[s
             - 'errors' (optional): list of game IDs that failed if errors=True
     """
     
+    #Wrap game_id in a list if only a single game_id is provided
+    game_ids = [game_ids] if type(game_ids) != list else game_ids
+
     pbps = []
     if game_ids[0] == 'random':
         #Randomize selection of game_ids
-        #Some ids returned may be invalid (for example, 2020021300)
+        #Some ids returned may be invalid (for example, 2020022000)
         num = game_ids[1]
         start = game_ids[2] if len(game_ids) > 1 else 2007
         end = game_ids[3] if len(game_ids) > 2 else (date.today().year)-1
@@ -189,7 +216,7 @@ def nhl_scrape_game(game_ids:list[int], split_shifts:bool = False, remove:list[s
             
             #Track error
             error_ids.append(game_id)
- 
+            
     #Add all pbps together
     if not pbps:
         print("\rNo data returned.")
@@ -323,7 +350,7 @@ def nhl_scrape_season(season:int, split_shifts:bool = False, season_types:list[i
         split_shifts (bool, optional):
             If True, returns a dict with separate 'pbp' and 'shifts' DataFrames. Default is False.
         season_types (List[int], optional):
-            List of season_types to include in scraping process.  Default is all regular season and playoff games which are 2 and 3 respectfully.
+            List of season_types to include in scraping process.  Default is all regular season and playoff games which are 2 and 3 respectively.
         remove (List[str], optional):
             List of event types to remove from the result. Default is an empty list.
         start (str, optional): 
@@ -632,6 +659,41 @@ def nhl_scrape_draft_rankings(arg:str = 'now', category:int = 0):
     #Return: prospect rankings
     return data
 
+def nhl_scrape_game_info(game_ids:list[int]):
+    """
+    Given a set of game_ids (NHL API), return information for each game.
+
+    Args:
+        game_ids (List[int] or ['random', int, int, int]):
+            List of NHL game IDs to scrape or use ['random', n, start_year, end_year] to fetch n random games.
+    
+    Returns:
+        pd.DataFrame:
+            An DataFrame containing information for each game.    
+    """
+
+    print(f'Finding game information for games: {game_ids}')
+
+    link = 'https://api-web.nhle.com/v1/gamecenter'
+
+    #Scrape information
+    df = pd.concat([pd.json_normalize(rs.get(f'{link}/{game_id}/landing').json()) for game_id in game_ids])
+
+    #Add extra info
+    df['date'] = df['gameDate']
+    df['season_type'] = df['gameType']
+    df['away_team_abbr'] = df['awayTeam.abbrev']
+    df['home_team_abbr'] = df['homeTeam.abbrev']
+    df['game_title'] = df['away_team_abbr'] + " @ " + df['home_team_abbr'] + " - " + df['date']
+    df['estStartTime'] = pd.to_datetime(df['startTimeUTC']).dt.tz_convert('US/Eastern').dt.strftime("%I:%M %p")
+
+    front_col = ['id','season','date','season_type','game_title','away_team_abbr','home_team_abbr','estStartTime']
+    df = df[front_col+[col for col in df.columns.to_list() if col not in front_col]]
+
+    #Return: game information
+    return df
+
+
 def nhl_apply_xG(pbp: pd.DataFrame):
     """
     Given play-by-play data, return this data with xG-related columns
@@ -1023,7 +1085,7 @@ def nhl_calculate_stats(pbp:pd.DataFrame, type:Literal['skater','goalie','team']
         season (int): 
             The NHL season formatted such as "20242025".
         season_types (List[int], optional):
-            List of season_types to include in scraping process.  Default is all regular season and playoff games which are 2 and 3 respectfully.
+            List of season_types to include in scraping process.  Default is all regular season and playoff games which are 2 and 3 respectively.
         game_strength (str or list[str]):
             List of game strength states to include (e.g., ['5v5','5v4','4v5']).
         split_game (bool, optional):
@@ -1113,6 +1175,9 @@ def nhl_calculate_stats(pbp:pd.DataFrame, type:Literal['skater','goalie','team']
         #Find player headshot
         complete['Headshot'] = 'https://assets.nhle.com/mugs/nhl/'+complete['Season'].astype(str)+'/'+complete['Team']+'/'+complete['ID'].astype(int).astype(str)+'.png'
 
+        #Convert season name
+        complete['Season'] = complete['Season'].replace(SEASON_NAMES)
+
         head = ['Goalie','ID','Game'] if 'Game' in complete.columns else ['Goalie','ID']
         complete = complete[head+[
             "Season","Team",'WSBA',
@@ -1155,6 +1220,9 @@ def nhl_calculate_stats(pbp:pd.DataFrame, type:Literal['skater','goalie','team']
         complete['xGF%'] = complete['xGF']/(complete['xGF']+complete['xGA'])
         complete['FF%'] = complete['FF']/(complete['FF']+complete['FA'])
         complete['CF%'] = complete['CF']/(complete['CF']+complete['CA'])
+        
+        #Convert season name
+        complete['Season'] = complete['Season'].replace(SEASON_NAMES)
 
         head = ['Team','Game'] if 'Game' in complete.columns else ['Team']
         complete = complete[head+[
@@ -1250,6 +1318,9 @@ def nhl_calculate_stats(pbp:pd.DataFrame, type:Literal['skater','goalie','team']
             for stat in PER_SIXTY[:3]:
                 type_metrics.append(f'{type.capitalize()}{stat}')
 
+        #Convert season name
+        complete['Season'] = complete['Season'].replace(SEASON_NAMES)
+
         head = ['Player','ID','Game'] if 'Game' in complete.columns else ['Player','ID']
         complete = complete[head+[
             "Season","Team",'WSBA',
@@ -1363,19 +1434,37 @@ def nhl_plot_games(pbp:pd.DataFrame, events:list[str], strengths:Union[Literal['
     #Return: list of plotted game events
     return game_plots
 
-def repo_load_rosters(seasons = []):
-    #Returns roster data from repository
-    # param 'seasons' - list of seasons to include
+def repo_load_rosters(seasons:list[int] = []):
+    """
+    Returns roster data from repository
+
+    Args:
+        seasons (list[int], optional):
+            A DataFrame containing play-by-play event data.
+
+    Returns:
+        pd.DataFrame:
+            A DataFrame containing roster data for supplied seasons.
+    """
 
     data = pd.read_csv(DEFAULT_ROSTER)
-    if len(seasons)>0:
+    if not seasons:
         data = data.loc[data['season'].isin(seasons)]
 
     return data
 
-def repo_load_schedule(seasons = []):
-    #Returns schedule data from repository
-    # param 'seasons' - list of seasons to include
+def repo_load_schedule(seasons:list[int] = []):
+    """
+    Returns schedule data from repository
+
+    Args:
+        seasons (list[int], optional):
+            A DataFrame containing play-by-play event data.
+
+    Returns:
+        pd.DataFrame:
+            A DataFrame containing the schedule data for the specified season and date range.    
+    """
 
     data = pd.read_csv(SCHEDULE_PATH)
     if len(seasons)>0:
@@ -1384,12 +1473,30 @@ def repo_load_schedule(seasons = []):
     return data
 
 def repo_load_teaminfo():
-    #Returns team data from repository
+    """
+    Returns team data from repository
+
+    Args:
+
+    Returns:
+        pd.DataFrame:
+            A DataFrame containing general team information.
+    """
 
     return pd.read_csv(INFO_PATH)
 
-def repo_load_pbp(seasons = []):
-    #Returns play-by-play data from repository
+def repo_load_pbp(seasons:list = []):
+    """
+    Returns play-by-play data from repository
+
+    Args:
+        seasons (List[int], optional): 
+                The NHL season formatted such as "20242025".
+    Returns:
+        pd.DataFrame:
+            A DataFrame containing full play-by-play data for the selected season.
+    """
+    #
     # param 'seasons' - list of seasons to include
 
     #Add parquet to total
@@ -1399,6 +1506,209 @@ def repo_load_pbp(seasons = []):
     return pd.concat(dfs)
 
 def repo_load_seasons():
-    #List of available seasons to scrape
+    """
+    Returns list of available seasons
+
+    Args:
+
+    Returns:
+        pd.DataFrame:
+            A DataFrame containing a list of seasons available in the WSBA Hockey package.
+    """
 
     return SEASONS
+
+## CLASSES ##
+class NHL_Database:
+    """
+    A class for managing and analyzing NHL play-by-play data.
+
+    This class supports game scraping, filtering, stat calculation, and plotting.
+    It initializes with either a provided list of game IDs or a default/random set.
+
+    Attributes:
+        name (str):
+            Designated name of the database.
+        pbp (pd.DataFrame): 
+            Combined play-by-play data for selected games.
+        games (list[int]): 
+            Unique game IDs currently in the dataset.
+        stats (dict[str, dict[str, pd.DataFrame]]): 
+            Dictionary storing calculated stats by type and name.
+        plots (dict[int, matplotlib.figure.Figure]): 
+            Dictionary storing plot outputs keyed by game or event.
+
+    Args:
+        game_ids (list[int], optional): 
+            List of game IDs to scrape initially.
+        pbp (pd.DataFrame, optional): 
+            Existing PBP DataFrame to load instead of scraping.
+    """
+
+    def __init__(self, name:str, game_ids:list[int] = [], pbp:pd.DataFrame = pd.DataFrame()):
+        """
+        Initialize the WSBA_Database with scraped or preloaded PBP data.
+
+        If no `pbp` is provided and `game_ids` is empty, a random set of games will be scraped.
+
+        Args:
+            name (str):
+                Name of database.
+            game_ids (list[int], optional): 
+                List of NHL game IDs to scrape in initialization.
+            pbp (pd.DataFrame, optional): 
+                Existing play-by-play data to initialization.
+
+        Returns:
+            pd.DataFrame: 
+                The initialized play-by-play dataset.
+        """
+
+        print(f'Initializing database "{name}"...')
+        self.name = name
+
+        if game_ids:
+            self.pbp = nhl_apply_xG(nhl_scrape_game(game_ids))
+        else:
+            self.pbp = nhl_apply_xG(nhl_scrape_game(['random',3,2007,2024])) if pbp.empty else pbp
+
+        self.games = self.pbp['game_id'].drop_duplicates().to_list()
+        self.stats = {}
+        self.plots = {}
+        
+    def add_games(self, game_ids:list[int]):
+        """
+        Add additional games to the existing play-by-play dataset.
+
+        Args:
+            game_ids (list[int]): 
+                List of game IDs to scrape and append.
+
+        Returns:
+            pd.DataFrame: 
+                The updated play-by-play dataset.
+        """
+
+        print('Adding games...')
+        self.pbp = pd.concat([self.pbp,nhl_apply_xG(wsba.nhl_scrape_game(game_ids))])
+
+        return self.pbp
+    
+    def select_games(self, game_ids:list[int]):
+        """
+        Return a filtered subset of the PBP data for specific games.
+
+        Args:
+            game_ids (list[int]): 
+                List of game IDs to include.
+
+        Returns:
+            pd.DataFrame: 
+                Filtered PBP data matching the selected games.
+        """
+         
+        print('Selecting games...')
+
+        df = self.pbp
+        return df.loc[df['game_id'].isin(game_ids)]
+
+    def add_stats(self, name:str, type:Literal['skater','goalie','team'], season_types:list[int], game_strength: Union[Literal['all'], list[str]], split_game:bool = False, roster_path:str = DEFAULT_ROSTER, shot_impact:bool = False):
+        """
+        Calculate and store statistics for the given play-by-play data.
+
+        Args:
+            name (str): 
+                Key name to store the results under.
+            type (Literal['skater', 'goalie', 'team']):
+                Type of statistics to calculate. Must be one of 'skater', 'goalie', or 'team'.
+            season (int): 
+                The NHL season formatted such as "20242025".
+            season_types (List[int], optional):
+                List of season_types to include in scraping process.  Default is all regular season and playoff games which are 2 and 3 respectively.
+            game_strength (str or list[str]):
+                List of game strength states to include (e.g., ['5v5','5v4','4v5']).
+            split_game (bool, optional):
+                If True, aggregates stats separately for each game; otherwise, stats are aggregated across all games.  Default is False.
+            roster_path (str, optional):
+                File path to the roster data used for mapping players and teams.
+            shot_impact (bool, optional):
+                If True, applies shot impact metrics to the stats DataFrame.  Default is False.
+
+        Returns:
+            pd.DataFrame: 
+                The calculated statistics.
+        """
+
+        df =  wsba.nhl_calculate_stats(self.pbp, type, season_types, game_strength, split_game, roster_path, shot_impact)
+        self.stats.update({type:{name:df}})
+
+        return df
+    
+    def add_game_plots(self, events:list[str], strengths:Union[Literal['all'], list[str]], game_ids: Union[Literal['all'], list[int]] = 'all', marker_dict:dict = event_markers, team_colors:dict = {'away':'primary','home':'primary'}, legend:bool = False):
+        """
+        Generate visualizations of game events based on play-by-play data.
+
+        Args:
+            events (list[str]):
+                List of event types to include in the plot (e.g., ['shot-on-goal', 'goal']).
+            strengths (str or list[str]):
+                List of game strength states to include (e.g., ['5v5','5v4','4v5']).
+            game_ids (str or list[int]):
+                List of game IDs to plot. If set to 'all', plots will be generated for all games in the DataFrame.
+            marker_dict (dict[str, dict]):
+                Dictionary mapping event types to marker styles and/or colors used in plotting.
+            legend (bool):
+                Whether to include a legend on the plots.
+
+        Returns:
+            dict[int, matplotlib.figure.Figure]:
+                A dictionary mapping each game ID to its corresponding matplotlib event plot figure.
+        """
+        
+        self.plots.update(nhl_plot_games(self.pbp, events, strengths, game_ids, marker_dict, team_colors, legend))
+
+        return self.plots    
+    
+    def export_data(self, path:str = ''):
+        """
+        Export the data within the object to a specified directory.
+
+        The method writes:
+        - The full play-by-play DataFrame to a CSV file.
+        - All calculated statistics by type and name to CSV files in subfolders.
+        - All stored plots to PNG files.
+
+        If no path is provided, exports to a folder named after the database (`self.name/`).
+
+        Args:
+            path (str, optional): 
+                Root folder to export data into. Defaults to `self.name/`.
+        """
+
+        print(f'Exporting data in database "{self.name}"...')
+        start = time.perf_counter()
+
+        # Use default path if none provided
+        path = f'{self.name}/' if path == '' else os.path.join(path,f'{self.name}')
+        os.makedirs(path, exist_ok=True)
+
+        # Export master PBP
+        self.pbp.to_csv(os.path.join(path, 'pbp.csv'), index=False)
+
+        # Export stats
+        for stat_type in self.stats.keys():
+            for name, df in self.stats[stat_type].items():
+                stat_path = os.path.join(path, 'stats', stat_type)
+                os.makedirs(stat_path, exist_ok=True)
+                df.to_csv(os.path.join(stat_path, f'{name}.csv'), index=False)
+
+        # Export plots
+        plot_path = os.path.join(path, 'plots')
+        os.makedirs(plot_path, exist_ok=True)
+        for game_id, plot in self.plots.items():
+            plot[0].savefig(os.path.join(plot_path, f'{game_id}.png'))
+
+        # Completion message
+        end = time.perf_counter()
+        length = end - start
+        print(f"...finished in {length:.2f} {'seconds' if length < 60 else 'minutes'}.")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wsba_hockey
-Version: 1.1.8
+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,,