nbastatpy 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

nbastatpy/game.py

@@ -3,6 +3,7 @@ from typing import List
 import nba_api.stats.endpoints as nba
 import pandas as pd
 
+from nbastatpy.standardize import standardize_dataframe
 from nbastatpy.utils import Formatter
 
 
@@ -15,135 +16,235 @@ class Game:
         """
         self.game_id = Formatter.format_game_id(game_id)
 
-    def get_boxscore(self) -> List[pd.DataFrame]:
+    def get_boxscore(self, standardize: bool = False) -> List[pd.DataFrame]:
         """Gets traditional boxscore
 
+        Args:
+            standardize: Whether to apply data standardization
+
         Returns:
             List[pd.DataFrame]: list of dataframes (players, starters/bench, team)
         """
-        self.boxscore = nba.BoxScoreTraditionalV3(self.game_id).get_data_frames()
+        dfs = nba.BoxScoreTraditionalV3(self.game_id).get_data_frames()
+
+        if standardize:
+            dfs = [standardize_dataframe(df, data_type="game") for df in dfs]
+
+        self.boxscore = dfs
         return self.boxscore
 
-    def get_advanced(self):
+    def get_advanced(self, standardize: bool = False):
         """
         Retrieves the advanced box score data for the game.
 
+        Args:
+            standardize: Whether to apply data standardization
+
         Returns:
             pandas.DataFrame: The advanced box score data for the game.
         """
-        self.adv_box = nba.BoxScoreAdvancedV3(self.game_id).get_data_frames()
+        dfs = nba.BoxScoreAdvancedV3(self.game_id).get_data_frames()
+
+        if standardize:
+            dfs = [standardize_dataframe(df, data_type="game") for df in dfs]
+
+        self.adv_box = dfs
         return self.adv_box
 
-    def get_defense(self):
+    def get_defense(self, standardize: bool = False):
         """
         Retrieves the defensive statistics for the game.
 
+        Args:
+            standardize: Whether to apply data standardization
+
         Returns:
             def_box (pandas.DataFrame): DataFrame containing the defensive statistics.
         """
-        self.def_box = nba.BoxScoreDefensiveV2(self.game_id).get_data_frames()
+        dfs = nba.BoxScoreDefensiveV2(self.game_id).get_data_frames()
+
+        if standardize:
+            dfs = [standardize_dataframe(df, data_type="game") for df in dfs]
+
+        self.def_box = dfs
         return self.def_box
 
-    def get_four_factors(self):
+    def get_four_factors(self, standardize: bool = False):
         """
         Retrieves the four factors data for the game.
 
+        Args:
+            standardize: Whether to apply data standardization
+
         Returns:
             pandas.DataFrame: The four factors data for the game.
         """
-        self.four_factors = nba.BoxScoreFourFactorsV3(self.game_id).get_data_frames()
+        dfs = nba.BoxScoreFourFactorsV3(self.game_id).get_data_frames()
+
+        if standardize:
+            dfs = [standardize_dataframe(df, data_type="game") for df in dfs]
+
+        self.four_factors = dfs
         return self.four_factors
 
-    def get_hustle(self) -> List[pd.DataFrame]:
+    def get_hustle(self, standardize: bool = False) -> List[pd.DataFrame]:
         """Gets hustle data for a given game
 
+        Args:
+            standardize: Whether to apply data standardization
+
         Returns:
             List[pd.DataFrame]: list of two dataframes (players, teams)
         """
-        self.hustle = nba.BoxScoreHustleV2(self.game_id).get_data_frames()
+        dfs = nba.BoxScoreHustleV2(self.game_id).get_data_frames()
+
+        if standardize:
+            dfs = [standardize_dataframe(df, data_type="game") for df in dfs]
+
+        self.hustle = dfs
         return self.hustle
 
-    def get_matchups(self):
+    def get_matchups(self, standardize: bool = False):
         """
         Retrieves the matchups for the game.
 
+        Args:
+            standardize: Whether to apply data standardization
+
         Returns:
             pandas.DataFrame: The matchups data for the game.
         """
-        self.matchups = nba.BoxScoreMatchupsV3(self.game_id).get_data_frames()
+        dfs = nba.BoxScoreMatchupsV3(self.game_id).get_data_frames()
+
+        if standardize:
+            dfs = [standardize_dataframe(df, data_type="game") for df in dfs]
+
+        self.matchups = dfs
         return self.matchups
 
-    def get_misc(self):
+    def get_misc(self, standardize: bool = False):
         """
         Retrieves miscellaneous box score data for the game.
 
+        Args:
+            standardize: Whether to apply data standardization
+
         Returns:
             pandas.DataFrame: The miscellaneous box score data.
         """
-        self.misc = nba.BoxScoreMiscV3(self.game_id).get_data_frames()
+        dfs = nba.BoxScoreMiscV3(self.game_id).get_data_frames()
+
+        if standardize:
+            dfs = [standardize_dataframe(df, data_type="game") for df in dfs]
+
+        self.misc = dfs
         return self.misc
 
-    def get_scoring(self):
+    def get_scoring(self, standardize: bool = False):
         """
         Retrieves the scoring data for the game.
 
+        Args:
+            standardize: Whether to apply data standardization
+
         Returns:
             pandas.DataFrame: The scoring data for the game.
         """
-        self.scoring = nba.BoxScoreScoringV3(self.game_id).get_data_frames()
+        dfs = nba.BoxScoreScoringV3(self.game_id).get_data_frames()
+
+        if standardize:
+            dfs = [standardize_dataframe(df, data_type="game") for df in dfs]
+
+        self.scoring = dfs
         return self.scoring
 
-    def get_usage(self) -> List[pd.DataFrame]:
+    def get_usage(self, standardize: bool = False) -> List[pd.DataFrame]:
         """Gets usage data for a given game
 
+        Args:
+            standardize: Whether to apply data standardization
+
         Returns:
             List[pd.DataFrame]: list of two dataframes (players, teams)
         """
-        self.usage = nba.BoxScoreUsageV3(self.game_id).get_data_frames()
+        dfs = nba.BoxScoreUsageV3(self.game_id).get_data_frames()
+
+        if standardize:
+            dfs = [standardize_dataframe(df, data_type="game") for df in dfs]
+
+        self.usage = dfs
         return self.usage
 
-    def get_playertrack(self):
+    def get_playertrack(self, standardize: bool = False):
         """
         Retrieves the player tracking data for the game.
 
+        Args:
+            standardize: Whether to apply data standardization
+
         Returns:
             playertrack (pandas.DataFrame): The player tracking data for the game.
         """
-        self.playertrack = nba.BoxScorePlayerTrackV3(self.game_id).get_data_frames()
+        dfs = nba.BoxScorePlayerTrackV3(self.game_id).get_data_frames()
+
+        if standardize:
+            dfs = [standardize_dataframe(df, data_type="game") for df in dfs]
+
+        self.playertrack = dfs
         return self.playertrack
 
-    def get_rotations(self):
+    def get_rotations(self, standardize: bool = False):
         """
         Retrieves the rotations data for the game.
 
+        Args:
+            standardize: Whether to apply data standardization
+
         Returns:
             pandas.DataFrame: The rotations data for the game.
         """
-        self.rotations = pd.concat(
-            nba.GameRotation(game_id=self.game_id).get_data_frames()
-        )
+        df = pd.concat(nba.GameRotation(game_id=self.game_id).get_data_frames())
+
+        if standardize:
+            df = standardize_dataframe(df, data_type="game")
+
+        self.rotations = df
         return self.rotations
 
-    def get_playbyplay(self) -> pd.DataFrame:
+    def get_playbyplay(self, standardize: bool = False) -> pd.DataFrame:
         """
         Retrieves the play-by-play data for the game.
 
+        Args:
+            standardize: Whether to apply data standardization
+
         Returns:
             pd.DataFrame: The play-by-play data as a pandas DataFrame.
         """
-        self.playbyplay = nba.PlayByPlayV3(self.game_id).get_data_frames()[0]
+        df = nba.PlayByPlayV3(self.game_id).get_data_frames()[0]
+
+        if standardize:
+            df = standardize_dataframe(df, data_type="game")
+
+        self.playbyplay = df
         return self.playbyplay
 
-    def get_win_probability(self) -> pd.DataFrame:
+    def get_win_probability(self, standardize: bool = False) -> pd.DataFrame:
         """
         Retrieves the win probability data for the game.
 
+        Args:
+            standardize: Whether to apply data standardization
+
         Returns:
             pd.DataFrame: The win probability data as a pandas DataFrame.
         """
-        self.win_probability = nba.WinProbabilityPBP(
-            game_id=self.game_id
-        ).get_data_frames()[0]
+        df = nba.WinProbabilityPBP(game_id=self.game_id).get_data_frames()[0]
+
+        if standardize:
+            df = standardize_dataframe(df, data_type="game")
+
+        self.win_probability = df
         return self.win_probability
 
 

nbastatpy/player.py

@@ -9,6 +9,7 @@ from nba_api.stats.endpoints import leaguegamefinder
 from nba_api.stats.static import players, teams
 from PIL import Image
 
+from nbastatpy.standardize import standardize_dataframe
 from nbastatpy.utils import Formatter, PlayTypes
 
 
@@ -59,21 +60,26 @@ class Player:
         if playoffs:
             self.season_type = "Playoffs"
 
-
-    def get_common_info(self) -> pd.DataFrame:
+    def get_common_info(self, standardize: bool = False) -> pd.DataFrame:
         """Gets common info like height, weight, draft_year, etc. and sets as class attr
-        
+
+        Args:
+            standardize: Whether to apply data standardization
+
         Returns:
             pd.DataFrame: A DataFrame containing the common information of the player.
         """
-        self.common_info = (
-            nba.CommonPlayerInfo(self.id).get_data_frames()[0].iloc[0].to_dict()
-        )
+        df = nba.CommonPlayerInfo(self.id).get_data_frames()[0]
+
+        if standardize:
+            df = standardize_dataframe(df, data_type="player")
+
+        self.common_info = df.iloc[0].to_dict()
 
         for attr_name, value in self.common_info.items():
             setattr(self, attr_name.lower(), self.common_info.get(attr_name, None))
 
-        return self.common_info
+        return df
 
     def get_salary(self) -> pd.DataFrame:
         """
@@ -88,23 +94,32 @@ class Player:
         tables = soup.find_all("table")
         if len(tables) > 1:
             # Get the table rows
-            rows = [[cell.text.strip() for cell in row.find_all('td')] for row in tables[0].find_all('tr')]
+            rows = [
+                [cell.text.strip() for cell in row.find_all("td")]
+                for row in tables[0].find_all("tr")
+            ]
+
+            rows2 = [
+                [cell.text.strip() for cell in row.find_all("td")]
+                for row in tables[1].find_all("tr")
+            ]
 
-            rows2 = [[cell.text.strip() for cell in row.find_all('td')] for row in tables[1].find_all('tr')]
-            
             projected = pd.DataFrame(rows[1:], columns=rows[0])
             projected["Team"] = projected.columns[1]
-            projected = projected.rename(columns={projected.columns[1]:"Salary"})
+            projected = projected.rename(columns={projected.columns[1]: "Salary"})
             projected["Salary_Type"] = "Projected"
-            
+
             historical = pd.DataFrame(rows2[1:], columns=rows2[0])
             historical["Salary_Type"] = "Historical"
-            
+
             self.salary_df = pd.concat([projected, historical])
-            
+
         else:
             # Get the table rows
-            rows = [[cell.text.strip() for cell in row.find_all('td')] for row in tables[0].find_all('tr')]
+            rows = [
+                [cell.text.strip() for cell in row.find_all("td")]
+                for row in tables[0].find_all("tr")
+            ]
             self.salary_df = pd.DataFrame(rows[1:], columns=rows[0])
 
         return self.salary_df
@@ -121,15 +136,24 @@ class Player:
         self.headshot = Image.open(BytesIO(pic.content))
         return self.headshot
 
-    def get_season_career_totals(self) -> pd.DataFrame:
+    def get_season_career_totals(self, standardize: bool = False) -> pd.DataFrame:
         """Gets seasons and career data
 
+        Args:
+            standardize: Whether to apply data standardization
+
         Returns:
             pd.DataFrame: 2 dataframes, season totals and career
         """
         df_list = nba.PlayerCareerStats(player_id=self.id).get_data_frames()
-        self.career_totals = df_list[1]
-        self.season_totals = df_list[0]
+
+        if standardize:
+            self.career_totals = standardize_dataframe(df_list[1], data_type="player")
+            self.season_totals = standardize_dataframe(df_list[0], data_type="player")
+        else:
+            self.career_totals = df_list[1]
+            self.season_totals = df_list[0]
+
         return self.season_totals, self.career_totals
 
     def get_splits(self) -> pd.DataFrame:
@@ -164,7 +188,6 @@ class Player:
         return self.game_splits
 
     def get_shooting_splits(self) -> pd.DataFrame:
-
         self.shooting_splits = pd.concat(
             nba.PlayerDashboardByShootingSplits(
                 self.id,
@@ -209,18 +232,31 @@ class Player:
         self.awards = nba.PlayerAwards(self.id).get_data_frames()[0]
         return self.awards
 
-    def get_games_boxscore(self) -> pd.DataFrame:
+    def get_games_boxscore(self, standardize: bool = False) -> pd.DataFrame:
         """
         Retrieves the boxscore data for the games played by the player.
 
+        Args:
+            standardize: Whether to apply data standardization
+
         Returns:
             pd.DataFrame: The boxscore data for the player's games.
         """
-        self.games_boxscore = leaguegamefinder.LeagueGameFinder(
+        df = leaguegamefinder.LeagueGameFinder(
             player_id_nullable=self.id,
             season_nullable=self.season,
             season_type_nullable=self.season_type,
         ).get_data_frames()[0]
+
+        if standardize:
+            df = standardize_dataframe(
+                df,
+                data_type="player",
+                season=self.season,
+                playoffs=(self.season_type == "Playoffs"),
+            )
+
+        self.games_boxscore = df
         return self.games_boxscore
 
     def get_matchups(self, defense: bool = False) -> pd.DataFrame:
@@ -228,7 +264,7 @@ class Player:
         Retrieves the matchups data for the player.
 
         Args:
-            defense (bool, optional): If True, retrieves the defensive matchups data. 
+            defense (bool, optional): If True, retrieves the defensive matchups data.
                 If False, retrieves the offensive matchups data. Defaults to False.
 
         Returns: