wsba-hockey 1.1.7__tar.gz → 1.1.9__tar.gz

{wsba_hockey-1.1.7/src/wsba_hockey.egg-info → wsba_hockey-1.1.9}/PKG-INFO

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

{wsba_hockey-1.1.7 → wsba_hockey-1.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wsba_hockey"
-version = "1.1.7"
+version = "1.1.9"
 authors = [
   { name="Owen Singh", email="owenbksingh@gmail.com" },
 ]

wsba_hockey-1.1.9/src/wsba_hockey/__init__.py

@@ -0,0 +1,22 @@
+from wsba_hockey.wsba_main import (
+    nhl_scrape_game,
+    nhl_scrape_schedule,
+    nhl_scrape_season,
+    nhl_scrape_seasons_info,
+    nhl_scrape_standings,
+    nhl_scrape_roster,
+    nhl_scrape_draft_rankings,
+    nhl_scrape_prospects,
+    nhl_scrape_game_info,
+    nhl_calculate_stats,
+    nhl_apply_xG,
+    nhl_plot_skaters_shots,
+    nhl_plot_games,
+    repo_load_rosters,
+    repo_load_schedule,
+    repo_load_teaminfo,
+    repo_load_pbp,
+    repo_load_seasons
+)
+
+from wsba_hockey.wsba_main import NHL_Database

{wsba_hockey-1.1.7 → wsba_hockey-1.1.9}/src/wsba_hockey/data_pipelines.py

@@ -1,7 +1,7 @@
 import os
 import numpy as np
 import pandas as pd
-import wsba_main as wsba
+import wsba_hockey.wsba_main as wsba
 import numpy as np
 from datetime import datetime
 from gspread_pandas import Spread
@@ -14,7 +14,7 @@ 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)
+            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)

{wsba_hockey-1.1.7 → wsba_hockey-1.1.9}/src/wsba_hockey/tools/scraping.py

@@ -509,26 +509,26 @@ async def parse_html(info):
     
     data = pd.concat(event_log)
     data['event_type'] = data['event_type'].replace({
-     "PGSTR": "pre-game-start",
-     "PGEND": "pre-game-end",
-     'GSTR':"game-start",
-     "ANTHEM":"anthem",
-     "PSTR":"period-start",
-     "FAC":"faceoff",
-     "SHOT":"shot-on-goal",
-     "BLOCK":"blocked-shot",
-     "STOP":"stoppage",
-     "MISS":"missed-shot",
-     "HIT":"hit",
-     "GOAL":"goal",
-     "GIVE":"giveaway",
-     "TAKE":"takeaway",
-     "DELPEN":"delayed-penalty",
-     "PENL":"penalty",
-     "CHL":"challenge",
-     "SOC":'shootout-complete',
-     "PEND":"period-end",
-     "GEND":"game-end"
+        "PGSTR": "pre-game-start",
+        "PGEND": "pre-game-end",
+        'GSTR':"game-start",
+        "ANTHEM":"anthem",
+        "PSTR":"period-start",
+        "FAC":"faceoff",
+        "SHOT":"shot-on-goal",
+        "BLOCK":"blocked-shot",
+        "STOP":"stoppage",
+        "MISS":"missed-shot",
+        "HIT":"hit",
+        "GOAL":"goal",
+        "GIVE":"giveaway",
+        "TAKE":"takeaway",
+        "DELPEN":"delayed-penalty",
+        "PENL":"penalty",
+        "CHL":"challenge",
+        "SOC":'shootout-complete',
+        "PEND":"period-end",
+        "GEND":"game-end"
     })
     
     #Return: parsed HTML pbp

{wsba_hockey-1.1.7 → wsba_hockey-1.1.9}/src/wsba_hockey/workspace.py

@@ -1,15 +1,12 @@
 import numpy as np
 import pandas as pd
-import wsba_main as wsba
-import data_pipelines as data
+import wsba_hockey as wsba
+import wsba_hockey.data_pipelines as data
 import numpy as np
 
 season_load = wsba.repo_load_seasons()
-
 select = season_load[0:3]
 
-data.pbp(select)
-
 #pbp = data.load_pbp_db(select)
 
 #wsba.wsba_xG(pbp,hypertune=True,train=True,train_runs=30,cv_runs=30)

{wsba_hockey-1.1.7 → wsba_hockey-1.1.9}/src/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 *
@@ -16,44 +17,44 @@ from wsba_hockey.tools.plotting import *
 
 ## GLOBAL VARIABLES ##
 SEASONS = [
-    '20072008',
-    '20082009',
-    '20092010',
-    '20102011',
-    '20112012',
-    '20122013',
-    '20132014',
-    '20142015',
-    '20152016',
-    '20162017',
-    '20172018',
-    '20182019',
-    '20192020',
-    '20202021',
-    '20212022',
-    '20222023',
-    '20232024',
-    '20242025'
+    20072008,
+    20082009,
+    20092010,
+    20102011,
+    20112012,
+    20122013,
+    20132014,
+    20142015,
+    20152016,
+    20162017,
+    20172018,
+    20182019,
+    20192020,
+    20202021,
+    20212022,
+    20222023,
+    20232024,
+    20242025
 ]
 
-CONVERT_SEASONS = {'2007': '20072008', 
-                   '2008': '20082009', 
-                   '2009': '20092010', 
-                   '2010': '20102011', 
-                   '2011': '20112012', 
-                   '2012': '20122013', 
-                   '2013': '20132014', 
-                   '2014': '20142015', 
-                   '2015': '20152016', 
-                   '2016': '20162017', 
-                   '2017': '20172018', 
-                   '2018': '20182019', 
-                   '2019': '20192020', 
-                   '2020': '20202021', 
-                   '2021': '20212022', 
-                   '2022': '20222023', 
-                   '2023': '20232024', 
-                   '2024': '20242025'}
+CONVERT_SEASONS = {2007: 20072008, 
+                   2008: 20082009, 
+                   2009: 20092010, 
+                   2010: 20102011, 
+                   2011: 20112012, 
+                   2012: 20122013, 
+                   2013: 20132014, 
+                   2014: 20142015, 
+                   2015: 20152016, 
+                   2016: 20162017, 
+                   2017: 20172018, 
+                   2018: 20182019, 
+                   2019: 20192020, 
+                   2020: 20202021, 
+                   2021: 20212022, 
+                   2022: 20222023, 
+                   2023: 20232024, 
+                   2024: 20242025}
 
 CONVERT_TEAM_ABBR = {'L.A':'LAK',
                      'N.J':'NJD',
@@ -66,46 +67,25 @@ PER_SIXTY = ['Fi','xGi','Gi','A1','A2','P1','P','Si','OZF','NZF','DZF','FF','FA'
 #Some games in the API are specifically known to cause errors in scraping.
 #This list is updated as frequently as necessary
 KNOWN_PROBS = {
-    '2007020011':'Missing shifts data for game between Chicago and Minnesota.',
-    '2007021178':'Game between the Bruins and Sabres is missing data after the second period, for some reason.',
-    '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.',
-    '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.',
-    '2010020124':'Game between Capitals and Hurricanes is sporadically missing player on-ice data',
-    '2012020018':'HTML events contain mislabeled events.',
-    '2013020971':'On March 10th, 2014, Stars forward Rich Peverley suffered from a cardiac episode midgame and as a result, the remainder of the game was postponed.  \nThe game resumed on April 9th, and the only goal scorer in the game, Blue Jackets forward Nathan Horton, did not appear in the resumed game due to injury.  Interestingly, Horton would never play in the NHL again.',
-    '2018021133':'Game between Lightning and Capitals has incorrectly labeled event teams (i.e. WSH TAKEAWAY - #71 CIRELLI (Cirelli is a Tampa Bay skater in this game)).',
-    '2019020876':'Due to the frightening collapse of Blues defensemen Jay Bouwmeester, a game on February 2nd, 2020 between the Ducks and Blues was postponed.  \nWhen the game resumed, Ducks defensemen Hampus Lindholm, who assisted on a goal in the inital game, did not play in the resumed match.'
+    2007020011:'Missing shifts data for game between Chicago and Minnesota.',
+    2007021178:'Game between the Bruins and Sabres is missing data after the second period, for some reason.',
+    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.',
+    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.',
+    2010020124:'Game between Capitals and Hurricanes is sporadically missing player on-ice data',
+    2012020018:'HTML events contain mislabeled events.',
+    2013020971:'On March 10th, 2014, Stars forward Rich Peverley suffered from a cardiac episode midgame and as a result, the remainder of the game was postponed.  \nThe game resumed on April 9th, and the only goal scorer in the game, Blue Jackets forward Nathan Horton, did not appear in the resumed game due to injury.  Interestingly, Horton would never play in the NHL again.',
+    2018021133:'Game between Lightning and Capitals has incorrectly labeled event teams (i.e. WSH TAKEAWAY - #71 CIRELLI (Cirelli is a Tampa Bay skater in this game)).',
+    2019020876:'Due to the frightening collapse of Blues defensemen Jay Bouwmeester, a game on February 2nd, 2020 between the Ducks and Blues was postponed.  \nWhen the game resumed, Ducks defensemen Hampus Lindholm, who assisted on a goal in the inital game, did not play in the resumed match.'
 }
 
 SHOT_TYPES = ['wrist','deflected','tip-in','slap','backhand','snap','wrap-around','poke','bat','cradle','between-legs']
 
 NEW = 2024
 
-STANDINGS_END = {
-    '20072008':'04-06',
-    '20082009':'04-12',
-    '20092010':'04-11',
-    '20102011':'04-10',
-    '20112012':'04-07',
-    '20122013':'04-28',
-    '20132014':'04-13',
-    '20142015':'04-11',
-    '20152016':'04-10',
-    '20162017':'04-09',
-    '20172018':'04-08',
-    '20182019':'04-06',
-    '20192020':'03-11',
-    '20202021':'05-19',
-    '20212022':'04-01',
-    '20222023':'04-14',
-    '20232024':'04-18',
-    '20242025':'04-17'
-}
-
 EVENTS = ['faceoff','hit','giveaway','takeaway','blocked-shot','missed-shot','shot-on-goal','goal','penalty']
 
 DIR = os.path.dirname(os.path.realpath(__file__))
@@ -344,7 +324,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): 
@@ -455,12 +435,12 @@ def nhl_scrape_seasons_info(seasons:list[int] = []):
     else:
         return df.sort_values(by=['id'])
 
-def nhl_scrape_standings(arg:str = "now", season_type:int = 2):
+def nhl_scrape_standings(arg:str | int = "now", season_type:int = 2):
     """
     Returns standings or playoff bracket
     Args:
-        arg (str, optional):
-            Date formatted as 'YYYY-MM-DD' to scrape standings for specific date or 'now' for current standings. Default is 'now'.
+        arg (str or int, optional):
+            Date formatted as 'YYYY-MM-DD' to scrape standings, NHL season such as "20242025", or 'now' for current standings. Default is 'now'.
         season_type (int, optional):
             Part of season to scrape.  If 3 (playoffs) then scrape the playoff bracket for the season implied by arg. When arg = 'now' this is ignored. Default is 2.
 
@@ -488,7 +468,11 @@ def nhl_scrape_standings(arg:str = "now", season_type:int = 2):
         else:
             print(f"Scraping standings for date: {arg}")
 
-        api = f"https://api-web.nhle.com/v1/standings/{arg[4:8]}-{STANDINGS_END[arg]}"
+        season_data = rs.get('https://api.nhle.com/stats/rest/en/season').json()['data']
+        season_data = [s for s in season_data if s['id'] == arg][0]
+        end = season_data['regularSeasonEndDate'][0:10]
+
+        api = f"https://api-web.nhle.com/v1/standings/{end}"
         data = rs.get(api).json()['standings']
 
         return pd.json_normalize(data)
@@ -649,6 +633,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
@@ -1040,7 +1059,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):
@@ -1380,19 +1399,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:
@@ -1401,12 +1438,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
@@ -1416,6 +1471,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('Initializing database...')
+        self.name = name
+
+        if game_ids:
+            self.pbp = nhl_scrape_game(game_ids)
+        else:
+            self.pbp = nhl_scrape_game(['random',3,2010,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,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('Exporting data...')
+        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.7 → wsba_hockey-1.1.9/src/wsba_hockey.egg-info}/PKG-INFO

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