Upload 5 files

functions/df_update.py

@@ -0,0 +1,472 @@
+import polars as pl
+import numpy as np
+import joblib
+
+loaded_model = joblib.load('joblib_model/barrel_model.joblib')
+in_zone_model = joblib.load('joblib_model/in_zone_model_knn_20240410.joblib')
+attack_zone_model = joblib.load('joblib_model/model_attack_zone.joblib')
+xwoba_model = joblib.load('joblib_model/xwoba_model.joblib')
+px_model = joblib.load('joblib_model/linear_reg_model_x.joblib')
+pz_model = joblib.load('joblib_model/linear_reg_model_z.joblib')
+
+
+class df_update:
+    def __init__(self):
+        pass
+
+    def update(self, df_clone: pl.DataFrame):
+
+        df = df_clone.clone()
+        # Assuming px_model is defined and df is your DataFrame
+        hit_codes = ['single',
+            'double','home_run', 'triple']
+
+        ab_codes = ['single', 'strikeout', 'field_out',
+            'grounded_into_double_play', 'fielders_choice', 'force_out',
+            'double', 'field_error', 'home_run', 'triple',
+            'double_play',
+            'fielders_choice_out', 'strikeout_double_play',
+            'other_out','triple_play']
+
+
+        obp_true_codes = ['single', 'walk',
+            'double','home_run', 'triple',
+            'hit_by_pitch', 'intent_walk']
+
+        obp_codes = ['single', 'strikeout', 'walk', 'field_out',
+            'grounded_into_double_play', 'fielders_choice', 'force_out',
+            'double', 'sac_fly', 'field_error', 'home_run', 'triple',
+            'hit_by_pitch', 'double_play', 'intent_walk',
+            'fielders_choice_out', 'strikeout_double_play',
+            'sac_fly_double_play',
+            'other_out','triple_play']
+
+
+        contact_codes = ['In play, no out',
+                'Foul', 'In play, out(s)',
+            'In play, run(s)',
+            'Foul Bunt']
+
+        bip_codes = ['In play, no out', 'In play, run(s)','In play, out(s)']
+
+
+        conditions_barrel = [
+            df['launch_speed'].is_null(),
+            (df['launch_speed'] * 1.5 - df['launch_angle'] >= 117) & 
+            (df['launch_speed'] + df['launch_angle'] >= 124) & 
+            (df['launch_speed'] >= 98) & 
+            (df['launch_angle'] >= 4) & (df['launch_angle'] <= 50)
+        ]
+        choices_barrel = [False, True]
+
+        conditions_tb = [
+            (df['event_type'] == 'single'),
+            (df['event_type'] == 'double'),
+            (df['event_type'] == 'triple'),
+            (df['event_type'] == 'home_run')
+        ]
+        choices_tb = [1, 2, 3, 4]
+
+
+        conditions_woba = [
+            df['event_type'].is_in(['strikeout', 'field_out', 'sac_fly', 'force_out', 'grounded_into_double_play', 'fielders_choice', 'field_error', 'sac_bunt', 'double_play', 'fielders_choice_out', 'strikeout_double_play', 'sac_fly_double_play', 'other_out']),
+            df['event_type'] == 'walk',
+            df['event_type'] == 'hit_by_pitch',
+            df['event_type'] == 'single',
+            df['event_type'] == 'double',
+            df['event_type'] == 'triple',
+            df['event_type'] == 'home_run'
+        ]
+        choices_woba = [0, 0.689, 0.720, 0.881, 1.254, 1.589, 2.048]
+
+        woba_codes = ['strikeout', 'field_out', 'single', 'walk', 'hit_by_pitch', 'double', 'sac_fly', 'force_out', 'home_run', 'grounded_into_double_play', 'fielders_choice', 'field_error', 'triple', 'sac_bunt', 'double_play', 'fielders_choice_out', 'strikeout_double_play', 'sac_fly_double_play', 'other_out']
+
+        pitch_cat = {'FA': 'Fastball',
+                    'FF': 'Fastball',
+                    'FT': 'Fastball',
+                    'FC': 'Fastball',
+                    'FS': 'Off-Speed',
+                    'FO': 'Off-Speed',
+                    'SI': 'Fastball',
+                    'ST': 'Breaking',
+                    'SL': 'Breaking',
+                    'CU': 'Breaking',
+                    'KC': 'Breaking',
+                    'SC': 'Off-Speed',
+                    'GY': 'Off-Speed',
+                    'SV': 'Breaking',
+                    'CS': 'Breaking',
+                    'CH': 'Off-Speed',
+                    'KN': 'Off-Speed',
+                    'EP': 'Breaking',
+                    'UN': None,
+                    'IN': None,
+                    'PO': None,
+                    'AB': None,
+                    'AS': None,
+                    'NP': None}
+
+
+        df = df.with_columns([
+            pl.when(df['type_ab'].is_not_null()).then(1).otherwise(0).alias('pa'),
+            pl.when(df['is_pitch']).then(1).otherwise(0).alias('pitches'),
+            pl.when(df['sz_top'] == 0).then(None).otherwise(df['sz_top']).alias('sz_top'),
+            pl.when(df['sz_bot'] == 0).then(None).otherwise(df['sz_bot']).alias('sz_bot'),
+            pl.when(df['zone'] > 0).then(df['zone'] < 10).otherwise(None).alias('in_zone'),
+            pl.Series(px_model.predict(df[['x']].fill_null(0).to_numpy())[:, 0]).alias('px_predict'),
+            pl.Series(pz_model.predict(df[['y']].fill_null(0).to_numpy())[:, 0] + 3.2).alias('pz_predict'),
+            pl.Series(in_zone_model.predict(df[['px','pz','sz_top','sz_bot']].fill_null(0).to_numpy())[:]).alias('in_zone_predict'),
+            pl.Series(attack_zone_model.predict(df[['px','pz','sz_top','sz_bot']].fill_null(0).to_numpy())[:]).alias('attack_zone_predict'),
+            pl.when(df['event_type'].is_in(hit_codes)).then(True).otherwise(False).alias('hits'),
+            pl.when(df['event_type'].is_in(ab_codes)).then(True).otherwise(False).alias('ab'),
+            pl.when(df['event_type'].is_in(obp_true_codes)).then(True).otherwise(False).alias('on_base'),
+            pl.when(df['event_type'].is_in(obp_codes)).then(True).otherwise(False).alias('obp'),
+            pl.when(df['play_description'].is_in(bip_codes)).then(True).otherwise(False).alias('bip'),
+            pl.when(conditions_barrel[0]).then(choices_barrel[0]).when(conditions_barrel[1]).then(choices_barrel[1]).otherwise(None).alias('barrel'),
+            pl.when(df['launch_angle'].is_null()).then(False).when((df['launch_angle'] >= 8) & (df['launch_angle'] <= 32)).then(True).otherwise(None).alias('sweet_spot'),
+            pl.when(df['launch_speed'].is_null()).then(False).when(df['launch_speed'] >= 94.5).then(True).otherwise(None).alias('hard_hit'),
+            pl.when(conditions_tb[0]).then(choices_tb[0]).when(conditions_tb[1]).then(choices_tb[1]).when(conditions_tb[2]).then(choices_tb[2]).when(conditions_tb[3]).then(choices_tb[3]).otherwise(None).alias('tb'),
+            pl.when(conditions_woba[0]).then(choices_woba[0]).when(conditions_woba[1]).then(choices_woba[1]).when(conditions_woba[2]).then(choices_woba[2]).when(conditions_woba[3]).then(choices_woba[3]).when(conditions_woba[4]).then(choices_woba[4]).when(conditions_woba[5]).then(choices_woba[5]).when(conditions_woba[6]).then(choices_woba[6]).otherwise(None).alias('woba'),
+            pl.when((df['play_code'] == 'S') | (df['play_code'] == 'W') | (df['play_code'] == 'T')).then(1).otherwise(0).alias('whiffs'),
+            pl.when((df['play_code'] == 'S') | (df['play_code'] == 'W') | (df['play_code'] == 'T') | (df['play_code'] == 'C')).then(1).otherwise(0).alias('csw'),
+            pl.when(pl.col('is_swing').cast(pl.Boolean)).then(1).otherwise(0).alias('swings'),
+            pl.col('event_type').is_in(['strikeout','strikeout_double_play']).alias('k'),
+            pl.col('event_type').is_in(['walk', 'intent_walk']).alias('bb'),
+            pl.lit(None).alias('attack_zone'),
+            pl.lit(None).alias('woba_pred'),
+            pl.lit(None).alias('woba_pred_contact')
+
+        ])
+
+        df = df.with_columns([
+            pl.when(df['event_type'].is_in(woba_codes)).then(1).otherwise(None).alias('woba_codes'),
+            pl.when(df['event_type'].is_in(woba_codes)).then(1).otherwise(None).alias('xwoba_codes'),
+            pl.when((pl.col('tb') >= 0)).then(df['woba']).otherwise(None).alias('woba_contact'),
+            pl.when(pl.col('px').is_null()).then(pl.col('px_predict')).otherwise(pl.col('px')).alias('px'),
+            pl.when(pl.col('pz').is_null()).then(pl.col('pz_predict')).otherwise(pl.col('pz')).alias('pz'),
+            pl.when(pl.col('in_zone').is_null()).then(pl.col('in_zone_predict')).otherwise(pl.col('in_zone')).alias('in_zone'),
+            pl.when(df['launch_speed'].is_null()).then(None).otherwise(df['barrel']).alias('barrel'),
+            pl.lit('average').alias('average'),
+                pl.when(pl.col('in_zone') == False).then(True).otherwise(False).alias('out_zone'),
+            pl.when((pl.col('in_zone') == True) & (pl.col('swings') == 1)).then(True).otherwise(False).alias('zone_swing'),
+            pl.when((pl.col('in_zone') == True) & (pl.col('swings') == 1) & (pl.col('whiffs') == 0)).then(True).otherwise(False).alias('zone_contact'),
+            pl.when((pl.col('in_zone') == False) & (pl.col('swings') == 1)).then(True).otherwise(False).alias('ozone_swing'),
+            pl.when((pl.col('in_zone') == False) & (pl.col('swings') == 1) & (pl.col('whiffs') == 0)).then(True).otherwise(False).alias('ozone_contact'),
+            pl.when(pl.col('event_type').str.contains('strikeout')).then(True).otherwise(False).alias('k'),
+            pl.when(pl.col('event_type').is_in(['walk', 'intent_walk'])).then(True).otherwise(False).alias('bb'),
+            pl.when(pl.col('attack_zone').is_null()).then(pl.col('attack_zone_predict')).otherwise(pl.col('attack_zone')).alias('attack_zone'),
+            
+
+        ])
+
+        df = df.with_columns([
+            (df['k'].cast(pl.Float32) - df['bb'].cast(pl.Float32)).alias('k_minus_bb'),
+            (df['bb'].cast(pl.Float32) - df['k'].cast(pl.Float32)).alias('bb_minus_k'),
+            (df['launch_speed'] > 0).alias('bip_div'),
+            (df['attack_zone'] == 0).alias('heart'),
+            (df['attack_zone'] == 1).alias('shadow'),
+            (df['attack_zone'] == 2).alias('chase'),
+            (df['attack_zone'] == 3).alias('waste'),
+            ((df['attack_zone'] == 0) & (df['swings'] == 1)).alias('heart_swing'),
+            ((df['attack_zone'] == 1) & (df['swings'] == 1)).alias('shadow_swing'),
+            ((df['attack_zone'] == 2) & (df['swings'] == 1)).alias('chase_swing'),
+            ((df['attack_zone'] == 3) & (df['swings'] == 1)).alias('waste_swing'),
+            ((df['attack_zone'] == 0) & (df['whiffs'] == 1)).alias('heart_whiff'),
+            ((df['attack_zone'] == 1) & (df['whiffs'] == 1)).alias('shadow_whiff'),
+            ((df['attack_zone'] == 2) & (df['whiffs'] == 1)).alias('chase_whiff'),
+            ((df['attack_zone'] == 3) & (df['whiffs'] == 1)).alias('waste_whiff')
+        ])
+
+
+        [0, 0.689, 0.720, 0.881, 1.254, 1.589, 2.048]
+
+        df = df.with_columns([
+                pl.Series(
+                    [sum(x) for x in xwoba_model.predict_proba(df[['launch_angle', 'launch_speed']].fill_null(0).to_numpy()[:]) * ([0, 0.881, 1.254, 1.589, 2.048])]
+                ).alias('woba_pred_predict')
+            ])
+
+        df = df.with_columns([
+            pl.when(pl.col('event_type').is_in(['walk'])).then(0.689)
+            .when(pl.col('event_type').is_in(['hit_by_pitch'])).then(0.720)
+            .when(pl.col('event_type').is_in(['strikeout', 'strikeout_double_play'])).then(0)
+            .otherwise(pl.col('woba_pred_predict')).alias('woba_pred_predict')
+        ])
+
+        df = df.with_columns([
+            pl.when(pl.col('woba_codes').is_null()).then(None).otherwise(pl.col('woba_pred_predict')).alias('woba_pred'),
+            pl.when(pl.col('bip')!=1).then(None).otherwise(pl.col('woba_pred_predict')).alias('woba_pred_contact'),
+        ])
+
+        df = df.with_columns([
+            pl.when(pl.col('trajectory').is_in(['bunt_popup'])).then(pl.lit('popup'))
+            .when(pl.col('trajectory').is_in(['bunt_grounder'])).then(pl.lit('ground_ball'))
+            .when(pl.col('trajectory').is_in(['bunt_line_drive'])).then(pl.lit('line_drive'))
+            .when(pl.col('trajectory').is_in([''])).then(pl.lit(None))
+            .otherwise(pl.col('trajectory')).alias('trajectory')
+        ])
+
+
+        # Create one-hot encoded columns for the trajectory column
+        dummy_df = df.select(pl.col('trajectory')).to_dummies()
+
+        # Rename the one-hot encoded columns
+        dummy_df = dummy_df.rename({
+            'trajectory_fly_ball': 'trajectory_fly_ball',
+            'trajectory_ground_ball': 'trajectory_ground_ball',
+            'trajectory_line_drive': 'trajectory_line_drive',
+            'trajectory_popup': 'trajectory_popup'
+        })
+
+        # Ensure the columns are present in the DataFrame
+        for col in ['trajectory_fly_ball', 'trajectory_ground_ball', 'trajectory_line_drive', 'trajectory_popup']:
+            if col not in dummy_df.columns:
+                dummy_df = dummy_df.with_columns(pl.lit(0).alias(col))
+
+        # Join the one-hot encoded columns back to the original DataFrame
+        df = df.hstack(dummy_df)
+
+        # Check if 'trajectory_null' column exists and drop it
+        if 'trajectory_null' in df.columns:
+            df = df.drop('trajectory_null')
+            
+        return df
+
+    # Assuming df is your Polars DataFrame
+    def update_summary(self, df: pl.DataFrame, pitcher: bool = True) -> pl.DataFrame:
+        """
+        Update summary statistics for pitchers or batters.
+
+        Parameters:
+        df (pl.DataFrame): The input Polars DataFrame containing player statistics.
+        pitcher (bool): A flag indicating whether to calculate statistics for pitchers (True) or batters (False).
+
+        Returns:
+        pl.DataFrame: A Polars DataFrame with aggregated and calculated summary statistics.
+        """
+
+        # Determine the position based on the pitcher flag
+        if pitcher:
+            position = 'pitcher'
+        else:
+            position = 'batter'
+
+        # Group by position_id and position_name, then aggregate various statistics
+        df_summ = df.group_by([f'{position}_id', f'{position}_name']).agg([
+            pl.col('pa').sum().alias('pa'),
+            pl.col('ab').sum().alias('ab'),
+            pl.col('obp').sum().alias('obp_pa'),
+            pl.col('hits').sum().alias('hits'),
+            pl.col('on_base').sum().alias('on_base'),
+            pl.col('k').sum().alias('k'),
+            pl.col('bb').sum().alias('bb'),
+            pl.col('bb_minus_k').sum().alias('bb_minus_k'),
+            pl.col('csw').sum().alias('csw'),
+            pl.col('bip').sum().alias('bip'),
+            pl.col('bip_div').sum().alias('bip_div'),
+            pl.col('tb').sum().alias('tb'),
+            pl.col('woba').sum().alias('woba'),
+            pl.col('woba_contact').sum().alias('woba_contact'),
+            pl.col('woba_pred').sum().alias('xwoba'),
+            pl.col('woba_pred_contact').sum().alias('xwoba_contact'),
+            pl.col('woba_codes').sum().alias('woba_codes'),
+            pl.col('xwoba_codes').sum().alias('xwoba_codes'),
+            pl.col('hard_hit').sum().alias('hard_hit'),
+            pl.col('barrel').sum().alias('barrel'),
+            pl.col('sweet_spot').sum().alias('sweet_spot'),
+            pl.col('launch_speed').max().alias('max_launch_speed'),
+            pl.col('launch_speed').quantile(0.90).alias('launch_speed_90'),
+            pl.col('launch_speed').mean().alias('launch_speed'),
+            pl.col('launch_angle').mean().alias('launch_angle'),
+            pl.col('is_pitch').sum().alias('pitches'),
+            pl.col('swings').sum().alias('swings'),
+            pl.col('in_zone').sum().alias('in_zone'),
+            pl.col('out_zone').sum().alias('out_zone'),
+            pl.col('whiffs').sum().alias('whiffs'),
+            pl.col('zone_swing').sum().alias('zone_swing'),
+            pl.col('zone_contact').sum().alias('zone_contact'),
+            pl.col('ozone_swing').sum().alias('ozone_swing'),
+            pl.col('ozone_contact').sum().alias('ozone_contact'),
+            pl.col('trajectory_ground_ball').sum().alias('ground_ball'),
+            pl.col('trajectory_line_drive').sum().alias('line_drive'),
+            pl.col('trajectory_fly_ball').sum().alias('fly_ball'),
+            pl.col('trajectory_popup').sum().alias('pop_up'),
+            pl.col('attack_zone').count().alias('attack_zone'),
+            pl.col('heart').sum().alias('heart'),
+            pl.col('shadow').sum().alias('shadow'),
+            pl.col('chase').sum().alias('chase'),
+            pl.col('waste').sum().alias('waste'),
+            pl.col('heart_swing').sum().alias('heart_swing'),
+            pl.col('shadow_swing').sum().alias('shadow_swing'),
+            pl.col('chase_swing').sum().alias('chase_swing'),
+            pl.col('waste_swing').sum().alias('waste_swing'),
+            pl.col('heart_whiff').sum().alias('heart_whiff'),
+            pl.col('shadow_whiff').sum().alias('shadow_whiff'),
+            pl.col('chase_whiff').sum().alias('chase_whiff'),
+            pl.col('waste_whiff').sum().alias('waste_whiff')
+        ])
+
+        # Add calculated columns to the summary DataFrame
+        df_summ = df_summ.with_columns([
+            (pl.col('hits') / pl.col('ab')).alias('avg'),
+            (pl.col('on_base') / pl.col('obp_pa')).alias('obp'),
+            (pl.col('tb') / pl.col('ab')).alias('slg'),
+            (pl.col('on_base') / pl.col('obp_pa') + pl.col('tb') / pl.col('ab')).alias('ops'),
+            (pl.col('k') / pl.col('pa')).alias('k_percent'),
+            (pl.col('bb') / pl.col('pa')).alias('bb_percent'),
+            (pl.col('bb_minus_k') / pl.col('pa')).alias('bb_minus_k_percent'),
+            (pl.col('bb') / pl.col('k')).alias('bb_over_k_percent'),
+            (pl.col('csw') / pl.col('pitches')).alias('csw_percent'),
+            (pl.col('sweet_spot') / pl.col('bip_div')).alias('sweet_spot_percent'),
+            (pl.col('woba') / pl.col('woba_codes')).alias('woba_percent'),
+            (pl.col('woba_contact') / pl.col('bip')).alias('woba_percent_contact'),
+            (pl.col('hard_hit') / pl.col('bip_div')).alias('hard_hit_percent'),
+            (pl.col('barrel') / pl.col('bip_div')).alias('barrel_percent'),
+            (pl.col('zone_contact') / pl.col('zone_swing')).alias('zone_contact_percent'),
+            (pl.col('zone_swing') / pl.col('in_zone')).alias('zone_swing_percent'),
+            (pl.col('in_zone') / pl.col('pitches')).alias('zone_percent'),
+            (pl.col('ozone_swing') / (pl.col('pitches') - pl.col('in_zone'))).alias('chase_percent'),
+            (pl.col('ozone_contact') / pl.col('ozone_swing')).alias('chase_contact'),
+            (pl.col('swings') / pl.col('pitches')).alias('swing_percent'),
+            (pl.col('whiffs') / pl.col('swings')).alias('whiff_rate'),
+            (pl.col('whiffs') / pl.col('pitches')).alias('swstr_rate'),
+            (pl.col('ground_ball') / pl.col('bip')).alias('ground_ball_percent'),
+            (pl.col('line_drive') / pl.col('bip')).alias('line_drive_percent'),
+            (pl.col('fly_ball') / pl.col('bip')).alias('fly_ball_percent'),
+            (pl.col('pop_up') / pl.col('bip')).alias('pop_up_percent'),
+            (pl.col('heart') / pl.col('attack_zone')).alias('heart_zone_percent'),
+            (pl.col('shadow') / pl.col('attack_zone')).alias('shadow_zone_percent'),
+            (pl.col('chase') / pl.col('attack_zone')).alias('chase_zone_percent'),
+            (pl.col('waste') / pl.col('attack_zone')).alias('waste_zone_percent'),
+            (pl.col('heart_swing') / pl.col('heart')).alias('heart_zone_swing_percent'),
+            (pl.col('shadow_swing') / pl.col('shadow')).alias('shadow_zone_swing_percent'),
+            (pl.col('chase_swing') / pl.col('chase')).alias('chase_zone_swing_percent'),
+            (pl.col('waste_swing') / pl.col('waste')).alias('waste_zone_swing_percent'),
+            (pl.col('heart_whiff') / pl.col('heart_swing')).alias('heart_zone_whiff_percent'),
+            (pl.col('shadow_whiff') / pl.col('shadow_swing')).alias('shadow_zone_whiff_percent'),
+            (pl.col('chase_whiff') / pl.col('chase_swing')).alias('chase_zone_whiff_percent'),
+            (pl.col('waste_whiff') / pl.col('waste_swing')).alias('waste_zone_whiff_percent'),
+            (pl.col('xwoba') / pl.col('xwoba_codes')).alias('xwoba_percent'),
+            (pl.col('xwoba_contact') / pl.col('bip')).alias('xwoba_percent_contact')
+        ])
+
+        return df_summ
+    
+
+
+
+
+    
+    # Assuming df is your Polars DataFrame
+    def update_summary_select(self, df: pl.DataFrame, selection: list) -> pl.DataFrame:
+        """
+        Update summary statistics for pitchers or batters.
+
+        Parameters:
+        df (pl.DataFrame): The input Polars DataFrame containing player statistics.
+        pitcher (bool): A flag indicating whether to calculate statistics for pitchers (True) or batters (False).
+
+        Returns:
+        pl.DataFrame: A Polars DataFrame with aggregated and calculated summary statistics.
+        """
+
+        # Group by position_id and position_name, then aggregate various statistics
+        df_summ = df.group_by(selection).agg([
+            pl.col('pa').sum().alias('pa'),
+            pl.col('ab').sum().alias('ab'),
+            pl.col('obp').sum().alias('obp_pa'),
+            pl.col('hits').sum().alias('hits'),
+            pl.col('on_base').sum().alias('on_base'),
+            pl.col('k').sum().alias('k'),
+            pl.col('bb').sum().alias('bb'),
+            pl.col('bb_minus_k').sum().alias('bb_minus_k'),
+            pl.col('csw').sum().alias('csw'),
+            pl.col('bip').sum().alias('bip'),
+            pl.col('bip_div').sum().alias('bip_div'),
+            pl.col('tb').sum().alias('tb'),
+            pl.col('woba').sum().alias('woba'),
+            pl.col('woba_contact').sum().alias('woba_contact'),
+            pl.col('woba_pred').sum().alias('xwoba'),
+            pl.col('woba_pred_contact').sum().alias('xwoba_contact'),
+            pl.col('woba_codes').sum().alias('woba_codes'),
+            pl.col('xwoba_codes').sum().alias('xwoba_codes'),
+            pl.col('hard_hit').sum().alias('hard_hit'),
+            pl.col('barrel').sum().alias('barrel'),
+            pl.col('sweet_spot').sum().alias('sweet_spot'),
+            pl.col('launch_speed').max().alias('max_launch_speed'),
+            pl.col('launch_speed').quantile(0.90).alias('launch_speed_90'),
+            pl.col('launch_speed').mean().alias('launch_speed'),
+            pl.col('launch_angle').mean().alias('launch_angle'),
+            pl.col('is_pitch').sum().alias('pitches'),
+            pl.col('swings').sum().alias('swings'),
+            pl.col('in_zone').sum().alias('in_zone'),
+            pl.col('out_zone').sum().alias('out_zone'),
+            pl.col('whiffs').sum().alias('whiffs'),
+            pl.col('zone_swing').sum().alias('zone_swing'),
+            pl.col('zone_contact').sum().alias('zone_contact'),
+            pl.col('ozone_swing').sum().alias('ozone_swing'),
+            pl.col('ozone_contact').sum().alias('ozone_contact'),
+            pl.col('trajectory_ground_ball').sum().alias('ground_ball'),
+            pl.col('trajectory_line_drive').sum().alias('line_drive'),
+            pl.col('trajectory_fly_ball').sum().alias('fly_ball'),
+            pl.col('trajectory_popup').sum().alias('pop_up'),
+            pl.col('attack_zone').count().alias('attack_zone'),
+            pl.col('heart').sum().alias('heart'),
+            pl.col('shadow').sum().alias('shadow'),
+            pl.col('chase').sum().alias('chase'),
+            pl.col('waste').sum().alias('waste'),
+            pl.col('heart_swing').sum().alias('heart_swing'),
+            pl.col('shadow_swing').sum().alias('shadow_swing'),
+            pl.col('chase_swing').sum().alias('chase_swing'),
+            pl.col('waste_swing').sum().alias('waste_swing'),
+            pl.col('heart_whiff').sum().alias('heart_whiff'),
+            pl.col('shadow_whiff').sum().alias('shadow_whiff'),
+            pl.col('chase_whiff').sum().alias('chase_whiff'),
+            pl.col('waste_whiff').sum().alias('waste_whiff')
+        ])
+
+        # Add calculated columns to the summary DataFrame
+        df_summ = df_summ.with_columns([
+            (pl.col('hits') / pl.col('ab')).alias('avg'),
+            (pl.col('on_base') / pl.col('obp_pa')).alias('obp'),
+            (pl.col('tb') / pl.col('ab')).alias('slg'),
+            (pl.col('on_base') / pl.col('obp_pa') + pl.col('tb') / pl.col('ab')).alias('ops'),
+            (pl.col('k') / pl.col('pa')).alias('k_percent'),
+            (pl.col('bb') / pl.col('pa')).alias('bb_percent'),
+            (pl.col('bb_minus_k') / pl.col('pa')).alias('bb_minus_k_percent'),
+            (pl.col('bb') / pl.col('k')).alias('bb_over_k_percent'),
+            (pl.col('csw') / pl.col('pitches')).alias('csw_percent'),
+            (pl.col('sweet_spot') / pl.col('bip_div')).alias('sweet_spot_percent'),
+            (pl.col('woba') / pl.col('woba_codes')).alias('woba_percent'),
+            (pl.col('woba_contact') / pl.col('bip')).alias('woba_percent_contact'),
+            (pl.col('hard_hit') / pl.col('bip_div')).alias('hard_hit_percent'),
+            (pl.col('barrel') / pl.col('bip_div')).alias('barrel_percent'),
+            (pl.col('zone_contact') / pl.col('zone_swing')).alias('zone_contact_percent'),
+            (pl.col('zone_swing') / pl.col('in_zone')).alias('zone_swing_percent'),
+            (pl.col('in_zone') / pl.col('pitches')).alias('zone_percent'),
+            (pl.col('ozone_swing') / (pl.col('pitches') - pl.col('in_zone'))).alias('chase_percent'),
+            (pl.col('ozone_contact') / pl.col('ozone_swing')).alias('chase_contact'),
+            (pl.col('swings') / pl.col('pitches')).alias('swing_percent'),
+            (pl.col('whiffs') / pl.col('swings')).alias('whiff_rate'),
+            (pl.col('whiffs') / pl.col('pitches')).alias('swstr_rate'),
+            (pl.col('ground_ball') / pl.col('bip')).alias('ground_ball_percent'),
+            (pl.col('line_drive') / pl.col('bip')).alias('line_drive_percent'),
+            (pl.col('fly_ball') / pl.col('bip')).alias('fly_ball_percent'),
+            (pl.col('pop_up') / pl.col('bip')).alias('pop_up_percent'),
+            (pl.col('heart') / pl.col('attack_zone')).alias('heart_zone_percent'),
+            (pl.col('shadow') / pl.col('attack_zone')).alias('shadow_zone_percent'),
+            (pl.col('chase') / pl.col('attack_zone')).alias('chase_zone_percent'),
+            (pl.col('waste') / pl.col('attack_zone')).alias('waste_zone_percent'),
+            (pl.col('heart_swing') / pl.col('heart')).alias('heart_zone_swing_percent'),
+            (pl.col('shadow_swing') / pl.col('shadow')).alias('shadow_zone_swing_percent'),
+            (pl.col('chase_swing') / pl.col('chase')).alias('chase_zone_swing_percent'),
+            (pl.col('waste_swing') / pl.col('waste')).alias('waste_zone_swing_percent'),
+            (pl.col('heart_whiff') / pl.col('heart_swing')).alias('heart_zone_whiff_percent'),
+            (pl.col('shadow_whiff') / pl.col('shadow_swing')).alias('shadow_zone_whiff_percent'),
+            (pl.col('chase_whiff') / pl.col('chase_swing')).alias('chase_zone_whiff_percent'),
+            (pl.col('waste_whiff') / pl.col('waste_swing')).alias('waste_zone_whiff_percent'),
+            (pl.col('xwoba') / pl.col('xwoba_codes')).alias('xwoba_percent'),
+            (pl.col('xwoba_contact') / pl.col('bip')).alias('xwoba_percent_contact')
+        ])
+
+        return df_summ

functions/pitch_summary_functions.py

@@ -0,0 +1,1152 @@
+import pandas as pd
+import numpy as np
+import json
+from  matplotlib.ticker import FuncFormatter
+from matplotlib.ticker import MaxNLocator
+import math
+from matplotlib.patches import Ellipse
+import matplotlib.transforms as transforms
+import matplotlib.colors
+import matplotlib.colors as mcolors
+import seaborn as sns
+import matplotlib.pyplot as plt
+import requests
+import polars as pl
+from PIL import Image
+import requests
+from io import BytesIO
+from matplotlib.offsetbox import OffsetImage, AnnotationBbox
+import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec
+import PIL
+from stuff_model import calculate_arm_angles as caa
+
+
+### PITCH COLOURS ###
+
+# Dictionary to map pitch types to their corresponding colors and names
+pitch_colours = {
+    ## Fastballs ##
+    'FF': {'colour': '#FF007D', 'name': '4-Seam Fastball'},
+    'FA': {'colour': '#FF007D', 'name': 'Fastball'},
+    'SI': {'colour': '#98165D', 'name': 'Sinker'},
+    'FC': {'colour': '#BE5FA0', 'name': 'Cutter'},
+
+    ## Offspeed ##
+    'CH': {'colour': '#F79E70', 'name': 'Changeup'},
+    'FS': {'colour': '#FE6100', 'name': 'Splitter'},
+    'SC': {'colour': '#F08223', 'name': 'Screwball'},
+    'FO': {'colour': '#FFB000', 'name': 'Forkball'},
+
+    ## Sliders ##
+    'SL': {'colour': '#67E18D', 'name': 'Slider'},
+    'ST': {'colour': '#1BB999', 'name': 'Sweeper'},
+    'SV': {'colour': '#376748', 'name': 'Slurve'},
+
+    ## Curveballs ##
+    'KC': {'colour': '#311D8B', 'name': 'Knuckle Curve'},
+    'CU': {'colour': '#3025CE', 'name': 'Curveball'},
+    'CS': {'colour': '#274BFC', 'name': 'Slow Curve'},
+    'EP': {'colour': '#648FFF', 'name': 'Eephus'},
+
+    ## Others ##
+    'KN': {'colour': '#867A08', 'name': 'Knuckleball'},
+    'KN': {'colour': '#867A08', 'name': 'Knuckle Ball'},
+    'PO': {'colour': '#472C30', 'name': 'Pitch Out'},
+    'UN': {'colour': '#9C8975', 'name': 'Unknown'},
+}
+
+# Create dictionaries for pitch types and their attributes
+dict_colour = {key: value['colour'] for key, value in pitch_colours.items()}
+dict_pitch = {key: value['name'] for key, value in pitch_colours.items()}
+dict_pitch_desc_type = {value['name']: key for key, value in pitch_colours.items()}
+dict_pitch_desc_type.update({'Four-Seam Fastball':'FF'})
+dict_pitch_desc_type.update({'All':'All'})
+dict_pitch_name = {value['name']: value['colour'] for key, value in pitch_colours.items()}
+dict_pitch_name.update({'Four-Seam Fastball':'#FF007D'})
+
+font_properties = {'family': 'calibi', 'size': 12}
+font_properties_titles = {'family': 'calibi', 'size': 20}
+font_properties_axes = {'family': 'calibi', 'size': 16}
+     
+cmap_sum = matplotlib.colors.LinearSegmentedColormap.from_list("", ['#648FFF','#FFFFFF','#FFB000',])
+
+### FANGRAPHS STATS DICT ###
+fangraphs_stats_dict = {'IP':{'table_header':'$\\bf{IP}$','format':'.1f',} ,
+ 'TBF':{'table_header':'$\\bf{PA}$','format':'.0f',} ,
+ 'AVG':{'table_header':'$\\bf{AVG}$','format':'.3f',} ,
+ 'K/9':{'table_header':'$\\bf{K\/9}$','format':'.2f',} ,
+ 'BB/9':{'table_header':'$\\bf{BB\/9}$','format':'.2f',} ,
+ 'K/BB':{'table_header':'$\\bf{K\/BB}$','format':'.2f',} ,
+ 'HR/9':{'table_header':'$\\bf{HR\/9}$','format':'.2f',} ,
+ 'K%':{'table_header':'$\\bf{K\%}$','format':'.1%',} ,
+ 'BB%':{'table_header':'$\\bf{BB\%}$','format':'.1%',} ,
+ 'K-BB%':{'table_header':'$\\bf{K-BB\%}$','format':'.1%',} ,
+ 'WHIP':{'table_header':'$\\bf{WHIP}$','format':'.2f',} ,
+ 'BABIP':{'table_header':'$\\bf{BABIP}$','format':'.3f',} ,
+ 'LOB%':{'table_header':'$\\bf{LOB\%}$','format':'.1%',} ,
+ 'xFIP':{'table_header':'$\\bf{xFIP}$','format':'.2f',} ,
+ 'FIP':{'table_header':'$\\bf{FIP}$','format':'.2f',} ,
+ 'H':{'table_header':'$\\bf{H}$','format':'.0f',} ,
+ '2B':{'table_header':'$\\bf{2B}$','format':'.0f',} ,
+ '3B':{'table_header':'$\\bf{3B}$','format':'.0f',} ,
+ 'R':{'table_header':'$\\bf{R}$','format':'.0f',} ,
+ 'ER':{'table_header':'$\\bf{ER}$','format':'.0f',} ,
+ 'HR':{'table_header':'$\\bf{HR}$','format':'.0f',} ,
+ 'BB':{'table_header':'$\\bf{BB}$','format':'.0f',} ,
+ 'IBB':{'table_header':'$\\bf{IBB}$','format':'.0f',} ,
+ 'HBP':{'table_header':'$\\bf{HBP}$','format':'.0f',} ,
+ 'SO':{'table_header':'$\\bf{SO}$','format':'.0f',} ,
+ 'OBP':{'table_header':'$\\bf{OBP}$','format':'.0f',} ,
+ 'SLG':{'table_header':'$\\bf{SLG}$','format':'.0f',} ,
+ 'ERA':{'table_header':'$\\bf{ERA}$','format':'.2f',} ,
+ 'wOBA':{'table_header':'$\\bf{wOBA}$','format':'.3f',} ,
+ 'G':{'table_header':'$\\bf{G}$','format':'.0f',}, 
+  'strikePercentage':{'table_header':'$\\bf{Strike\%}$','format':'.1%'} }
+
+colour_palette = ['#FFB000','#648FFF','#785EF0',
+                  '#DC267F','#FE6100','#3D1EB2','#894D80','#16AA02','#B5592B','#A3C1ED']
+
+### GET COLOURS ###
+def get_color(value, normalize, cmap_sum):
+    """
+    Get the color corresponding to a value based on a colormap and normalization.
+
+    Parameters
+    ----------
+    value : float
+        The value to be mapped to a color.
+    normalize : matplotlib.colors.Normalize
+        The normalization function to scale the value.
+    cmap_sum : matplotlib.colors.Colormap
+        The colormap to use for mapping the value to a color.
+
+    Returns
+    -------
+    str
+        The hexadecimal color code corresponding to the value.
+    """
+    color = cmap_sum(normalize(value))
+    return mcolors.to_hex(color)
+
+### PITCH ELLIPSE ###
+def confidence_ellipse(x, y, ax, n_std=3.0, facecolor='none', **kwargs):
+    """
+    Create a plot of the covariance confidence ellipse of *x* and *y*.
+
+    Parameters
+    ----------
+    x, y : array-like, shape (n, )
+        Input data.
+
+    ax : matplotlib.axes.Axes
+        The axes object to draw the ellipse into.
+
+    n_std : float
+        The number of standard deviations to determine the ellipse's radiuses.
+
+    **kwargs
+        Forwarded to `~matplotlib.patches.Ellipse`
+
+    Returns
+    -------
+    matplotlib.patches.Ellipse
+    """
+    
+    if len(x) != len(y):
+        raise ValueError("x and y must be the same size")
+    try:
+        cov = np.cov(x, y)
+        pearson = cov[0, 1]/np.sqrt(cov[0, 0] * cov[1, 1])
+        # Using a special case to obtain the eigenvalues of this
+        # two-dimensional dataset.
+        ell_radius_x = np.sqrt(1 + pearson)
+        ell_radius_y = np.sqrt(1 - pearson)
+        ellipse = Ellipse((0, 0), width=ell_radius_x * 2, height=ell_radius_y * 2,
+                        facecolor=facecolor,linewidth=2,linestyle='--', **kwargs)
+        
+
+        # Calculating the standard deviation of x from
+        # the squareroot of the variance and multiplying
+        # with the given number of standard deviations.
+        scale_x = np.sqrt(cov[0, 0]) * n_std
+        mean_x = x.mean()
+        
+
+        # calculating the standard deviation of y ...
+        scale_y = np.sqrt(cov[1, 1]) * n_std
+        mean_y = y.mean()
+        
+
+        transf = transforms.Affine2D() \
+            .rotate_deg(45) \
+            .scale(scale_x, scale_y) \
+            .translate(mean_x, mean_y)
+        
+        
+
+        ellipse.set_transform(transf + ax.transData)
+    except ValueError:
+         return    
+        
+    return ax.add_patch(ellipse)     
+### VELOCITY KDES ###
+def velocity_kdes(df: pl.DataFrame, ax: plt.Axes, gs: gridspec.GridSpec, gs_x: list, gs_y: list, fig: plt.Figure):
+    """
+    Plot the velocity KDEs for different pitch types.
+
+    Parameters
+    ----------
+    df : pl.DataFrame
+        The DataFrame containing pitch data.
+    ax : plt.Axes
+        The axis to plot on.
+    gs : GridSpec
+        The GridSpec for the subplot layout.
+    gs_x : list
+        The x-coordinates for the GridSpec.
+    gs_y : list
+        The y-coordinates for the GridSpec.
+    fig : plt.Figure
+        The figure to plot on.
+    """
+    # Get unique pitch types sorted by pitch count
+    items_in_order = df.sort("pitch_count", descending=True)['pitch_type'].unique(maintain_order=True).to_numpy()
+
+    # Create the inner subplot inside the outer subplot
+    ax.axis('off')
+    ax.set_title('Pitch Velocity Distribution', fontdict={'family': 'calibi', 'size': 20})
+    inner_grid_1 = gridspec.GridSpecFromSubplotSpec(len(items_in_order), 1, subplot_spec=gs[gs_x[0]:gs_x[-1], gs_y[0]:gs_y[-1]])
+    ax_top = [fig.add_subplot(inner) for inner in inner_grid_1]
+
+    for idx, i in enumerate(items_in_order):
+        pitch_data = df.filter(pl.col('pitch_type') == i)['start_speed']
+        if np.unique(pitch_data).size == 1:  # Check if all values are the same
+            ax_top[idx].plot([np.unique(pitch_data), np.unique(pitch_data)], [0, 1], linewidth=4, color=dict_colour[i], zorder=20)
+        else:
+            sns.kdeplot(pitch_data, ax=ax_top[idx], fill=True, clip=(pitch_data.min(), pitch_data.max()), color=dict_colour[i])
+
+        # Plot the mean release speed for the current data
+        df_average = df.filter(df['pitch_type'] == i)['start_speed']
+        ax_top[idx].plot([df_average.mean(), df_average.mean()], [ax_top[idx].get_ylim()[0], ax_top[idx].get_ylim()[1]], color=dict_colour[i], linestyle='--')
+
+        # Plot the mean release speed for the statcast group data
+        df_statcast_group = pl.read_csv('functions/statcast_2024_grouped.csv')
+        df_average = df_statcast_group.filter(df_statcast_group['pitch_type'] == i)['release_speed']
+        ax_top[idx].plot([df_average.mean(), df_average.mean()], [ax_top[idx].get_ylim()[0], ax_top[idx].get_ylim()[1]], color=dict_colour[i], linestyle=':')
+
+        ax_top[idx].set_xlim(math.floor(df['start_speed'].min() / 5) * 5, math.ceil(df['start_speed'].max() / 5) * 5)
+        ax_top[idx].set_xlabel('')
+        ax_top[idx].set_ylabel('')
+        if idx < len(items_in_order) - 1:
+            ax_top[idx].spines['top'].set_visible(False)
+            ax_top[idx].spines['right'].set_visible(False)
+            ax_top[idx].spines['left'].set_visible(False)
+            ax_top[idx].tick_params(axis='x', colors='none')
+
+        ax_top[idx].set_xticks(range(math.floor(df['start_speed'].min() / 5) * 5, math.ceil(df['start_speed'].max() / 5) * 5, 5))
+        ax_top[idx].set_yticks([])
+        ax_top[idx].grid(axis='x', linestyle='--')
+        ax_top[idx].text(-0.01, 0.5, i, transform=ax_top[idx].transAxes, fontsize=14, va='center', ha='right')
+
+    ax_top[-1].spines['top'].set_visible(False)
+    ax_top[-1].spines['right'].set_visible(False)
+    ax_top[-1].spines['left'].set_visible(False)
+    ax_top[-1].set_xticks(list(range(math.floor(df['start_speed'].min() / 5) * 5, math.ceil(df['start_speed'].max() / 5) * 5, 5)))
+    ax_top[-1].set_xlabel('Velocity (mph)')
+
+### TJ STUFF+ ROLLING ###
+def tj_stuff_roling(df: pl.DataFrame, window: int, ax: plt.Axes):
+    """
+    Plot the rolling average of tjStuff+ for different pitch types.
+
+    Parameters
+    ----------
+    df : pl.DataFrame
+        The DataFrame containing pitch data.
+    window : int
+        The window size for calculating the rolling average.
+    ax : plt.Axes
+        The axis to plot on.
+    """
+    # Get unique pitch types sorted by pitch count
+    items_in_order = df.sort("pitch_count", descending=True)['pitch_type'].unique(maintain_order=True).to_numpy()
+    
+    # Plot the rolling average for each pitch type
+    for i in items_in_order:
+        pitch_data = df.filter(pl.col('pitch_type') == i)
+        if pitch_data['pitch_count'].max() >= window:
+            sns.lineplot(
+                x=range(1, pitch_data['pitch_count'].max() + 1),
+                y=pitch_data['tj_stuff_plus'].rolling_mean(window),
+                color=dict_colour[i],
+                ax=ax,
+                linewidth=3
+            )
+
+    # Adjust x-axis limits to start from 1
+    ax.set_xlim(window, df['pitch_count'].max())
+    ax.set_ylim(70, 130)
+    ax.set_xlabel('Pitches', fontdict=font_properties_axes)
+    ax.set_ylabel('tjStuff+', fontdict=font_properties_axes)
+    ax.set_title(f"{window} Pitch Rolling tjStuff+", fontdict=font_properties_titles)
+    ax.xaxis.set_major_locator(MaxNLocator(integer=True))
+
+### TJ STUFF+ ROLLING ###
+def tj_stuff_roling_game(df: pl.DataFrame, window: int, ax: plt.Axes):
+    """
+    Plot the rolling average of tjStuff+ for different pitch types over games.
+
+    Parameters
+    ----------
+    df : pl.DataFrame
+        The DataFrame containing pitch data.
+    window : int
+        The window size for calculating the rolling average.
+    ax : plt.Axes
+        The axis to plot on.
+    """
+    # Map game_id to sequential numbers
+    date_to_number = {date: i + 1 for i, date in enumerate(df['game_id'].unique(maintain_order=True))}
+
+    # Add a column with the sequential game numbers
+    df_plot = df.with_columns(
+        pl.col("game_id").map_elements(lambda x: date_to_number.get(x, x)).alias("start_number")
+    )
+
+    # Group by relevant columns and calculate mean tj_stuff_plus
+    plot_game_roll = df_plot.group_by(['start_number', 'game_id', 'game_date', 'pitch_type', 'pitch_description']).agg(
+        pl.col('tj_stuff_plus').mean().alias('tj_stuff_plus')
+    ).sort('start_number', descending=False)
+
+    # Get the list of pitch types ordered by frequency
+    sorted_value_counts = df['pitch_type'].value_counts().sort('count', descending=True)
+    items_in_order = sorted_value_counts['pitch_type'].to_list()
+
+    # Plot the rolling average for each pitch type
+    for i in items_in_order:
+        df_item = plot_game_roll.filter(pl.col('pitch_type') == i)
+        df_item = df_item.with_columns(
+            pl.col("start_number").cast(pl.Int64)
+        ).join(
+            pl.DataFrame({"start_number": list(date_to_number.values())}),
+            on="start_number",
+            how="outer"
+        ).sort("start_number_right").with_columns([
+            pl.col("start_number").fill_null(strategy="forward").fill_null(strategy="backward"),
+            pl.col("tj_stuff_plus").fill_null(strategy="forward").fill_null(strategy="backward"),
+            pl.col("pitch_type").fill_null(strategy="forward").fill_null(strategy="backward"),
+            pl.col("pitch_description").fill_null(strategy="forward").fill_null(strategy="backward")
+        ])
+
+        sns.lineplot(x=range(1, max(df_item['start_number_right']) + 1),
+                        y=df_item.filter(pl.col('pitch_type') == i)['tj_stuff_plus'].rolling_mean(window,min_periods=1),
+                        color=dict_colour[i],
+                        ax=ax, linewidth=3)
+
+        # Highlight missing game data points
+        for n in range(len(df_item)):
+            if df_item['game_id'].is_null()[n]:
+                sns.scatterplot(x=[df_item['start_number_right'][n]],
+                                y=[df_item['tj_stuff_plus'].rolling_mean(window,min_periods=1)[n]],
+                                color='white',
+                                ec=dict_colour[i],
+                                ax=ax,
+                                zorder=100)
+
+    # Adjust x-axis limits to start from 1
+    ax.set_xlim(1, max(df_item['start_number']))
+    ax.set_ylim(70, 130)
+    ax.set_xlabel('Games', fontdict=font_properties_axes)
+    ax.set_ylabel('tjStuff+', fontdict=font_properties_axes)
+    ax.set_title(f"{window} Game Rolling tjStuff+", fontdict=font_properties_titles)
+    ax.xaxis.set_major_locator(MaxNLocator(integer=True))
+
+def break_plot(df: pl.DataFrame, ax: plt.Axes):
+    """
+    Plot the pitch breaks for different pitch types.
+
+    Parameters
+    ----------
+    df : pl.DataFrame
+        The DataFrame containing pitch data.
+    ax : plt.Axes
+        The axis to plot on.
+    """
+    # Get unique pitch types sorted by pitch count
+    label_labels = df.sort(by=['pitch_count', 'pitch_type'], descending=[False, True])['pitch_type'].unique(maintain_order=True).to_numpy()
+
+    # Plot confidence ellipses for each pitch type
+    for idx, label in enumerate(label_labels):
+        subset = df.filter(pl.col('pitch_type') == label)
+        if len(subset) > 4:
+            try:
+                confidence_ellipse(subset['hb'], subset['ivb'], ax=ax, edgecolor=dict_colour[label], n_std=2, facecolor=dict_colour[label], alpha=0.2)
+            except ValueError:
+                return
+
+    # Plot scatter plot for pitch breaks
+    if df['pitcher_hand'][0] == 'R':
+        sns.scatterplot(ax=ax, x=df['hb'], y=df['ivb'], hue=df['pitch_type'], palette=dict_colour, ec='black', alpha=1, zorder=2)
+    elif df['pitcher_hand'][0] == 'L':
+        sns.scatterplot(ax=ax, x=df['hb'], y=df['ivb'], hue=df['pitch_type'], palette=dict_colour, ec='black', alpha=1, zorder=2)
+
+    # Set axis limits
+    ax.set_xlim((-25, 25))
+    ax.set_ylim((-25, 25))
+
+
+    df_aa = caa.calculate_arm_angles(df,df['pitcher_id'][0])['arm_angle']
+
+    # Plot average arm angle
+    mean_arm_angle = df_aa.mean()
+    x_end = 30
+    y_end = x_end * np.tan(np.radians(mean_arm_angle))
+    ax.plot([0, x_end], [0, y_end], color='grey', linestyle='--', linewidth=2,zorder=0)
+
+    
+
+    # Add horizontal and vertical lines
+    ax.hlines(y=0, xmin=-50, xmax=50, color=colour_palette[8], alpha=0.5, linestyles='--', zorder=1)
+    ax.vlines(x=0, ymin=-50, ymax=50, color=colour_palette[8], alpha=0.5, linestyles='--', zorder=1)
+
+    # Set axis labels and title
+    ax.set_xlabel('Horizontal Break (in)', fontdict=font_properties_axes)
+    ax.set_ylabel('Induced Vertical Break (in)', fontdict=font_properties_axes)
+    ax.set_title(f"Pitch Breaks - Arm Angle: {mean_arm_angle:.0f}°", fontdict=font_properties_titles)
+
+    # Remove legend
+    ax.get_legend().remove()
+
+    # Set tick labels
+    ax.set_xticklabels(ax.get_xticks(), fontdict=font_properties)
+    ax.set_yticklabels(ax.get_yticks(), fontdict=font_properties)
+
+    # Add text annotations for glove side and arm side
+    if df['pitcher_hand'][0] == 'R':
+        ax.text(-24.5, -24.5, s='← Glove Side', fontstyle='italic', ha='left', va='bottom',
+                bbox=dict(facecolor='white', edgecolor='black'), fontsize=12, zorder=3)
+        ax.text(24.5, -24.5, s='Arm Side →', fontstyle='italic', ha='right', va='bottom',
+                bbox=dict(facecolor='white', edgecolor='black'), fontsize=12, zorder=3)
+    elif df['pitcher_hand'][0] == 'L':
+        ax.invert_xaxis()
+        ax.text(24.5, -24.5, s='← Arm Side', fontstyle='italic', ha='left', va='bottom',
+                bbox=dict(facecolor='white', edgecolor='black'), fontsize=12, zorder=3)
+        ax.text(-24.5, -24.5, s='Glove Side →', fontstyle='italic', ha='right', va='bottom',
+                bbox=dict(facecolor='white', edgecolor='black'), fontsize=12, zorder=3)
+
+    # Set aspect ratio and format axis ticks
+    ax.set_aspect('equal', adjustable='box')
+    ax.xaxis.set_major_formatter(FuncFormatter(lambda x, _: int(x)))
+    ax.yaxis.set_major_formatter(FuncFormatter(lambda x, _: int(x)))
+
+# DEFINE STRIKE ZONE
+strike_zone = pl.DataFrame({
+    'PlateLocSide': [-0.9, -0.9, 0.9, 0.9, -0.9],
+    'PlateLocHeight': [1.5, 3.5, 3.5, 1.5, 1.5]
+})
+
+### STRIKE ZONE ###
+def draw_line(axis, alpha_spot=1, catcher_p=True):
+    """
+    Draw the strike zone and home plate on the given axis.
+
+    Parameters
+    ----------
+    axis : matplotlib.axes.Axes
+        The axis to draw the strike zone on.
+    alpha_spot : float, optional
+        The transparency level of the lines (default is 1).
+    catcher_p : bool, optional
+        Whether to draw the catcher's perspective (default is True).
+    """
+    # Draw the strike zone
+    axis.plot(strike_zone['PlateLocSide'].to_list(), strike_zone['PlateLocHeight'].to_list(), 
+              color='black', linewidth=1.3, zorder=3, alpha=alpha_spot)
+
+    if catcher_p:
+        # Draw home plate from catcher's perspective
+        axis.plot([-0.708, 0.708], [0.15, 0.15], color='black', linewidth=1, alpha=alpha_spot, zorder=1)
+        axis.plot([-0.708, -0.708], [0.15, 0.3], color='black', linewidth=1, alpha=alpha_spot, zorder=1)
+        axis.plot([-0.708, 0], [0.3, 0.5], color='black', linewidth=1, alpha=alpha_spot, zorder=1)
+        axis.plot([0, 0.708], [0.5, 0.3], color='black', linewidth=1, alpha=alpha_spot, zorder=1)
+        axis.plot([0.708, 0.708], [0.3, 0.15], color='black', linewidth=1, alpha=alpha_spot, zorder=1)
+    else:
+        # Draw home plate from pitcher's perspective
+        axis.plot([-0.708, 0.708], [0.4, 0.4], color='black', linewidth=1, alpha=alpha_spot, zorder=1)
+        axis.plot([-0.708, -0.9], [0.4, -0.1], color='black', linewidth=1, alpha=alpha_spot, zorder=1)
+        axis.plot([-0.9, 0], [-0.1, -0.35], color='black', linewidth=1, alpha=alpha_spot, zorder=1)
+        axis.plot([0, 0.9], [-0.35, -0.1], color='black', linewidth=1, alpha=alpha_spot, zorder=1)
+        axis.plot([0.9, 0.708], [-0.1, 0.4], color='black', linewidth=1, alpha=alpha_spot, zorder=1)
+
+def location_plot(df: pl.DataFrame, ax: plt.Axes, hand: str):
+    """
+    Plot the pitch locations for different pitch types against a specific batter hand.
+
+    Parameters
+    ----------
+    df : pl.DataFrame
+        The DataFrame containing pitch data.
+    ax : plt.Axes
+        The axis to plot on.
+    hand : str
+        The batter hand ('L' for left-handed, 'R' for right-handed).
+    """
+    # Get unique pitch types sorted by pitch count
+    label_labels = df.sort(by=['pitch_count', 'pitch_type'], descending=[False, True])['pitch_type'].unique(maintain_order=True).to_numpy()
+
+    # Plot confidence ellipses for each pitch type
+    for label in label_labels:
+        subset = df.filter((pl.col('pitch_type') == label) & (pl.col('batter_hand') == hand))
+        if len(subset) >= 5:
+            confidence_ellipse(subset['px'], subset['pz'], ax=ax, edgecolor=dict_colour[label], n_std=1.5, facecolor=dict_colour[label], alpha=0.3)
+
+    # Group pitch locations by pitch type and calculate mean values
+    pitch_location_group = (
+        df.filter(pl.col("batter_hand") == hand)
+        .group_by("pitch_type")
+        .agg([
+            pl.col("start_speed").count().alias("pitches"),
+            pl.col("px").mean().alias("px"),
+            pl.col("pz").mean().alias("pz")
+        ])
+    )
+
+    # Calculate pitch percentages
+    total_pitches = pitch_location_group['pitches'].sum()
+    pitch_location_group = pitch_location_group.with_columns(
+        (pl.col("pitches") / total_pitches).alias("pitch_percent")
+    )
+
+    # Plot pitch locations
+    sns.scatterplot(ax=ax, x=pitch_location_group['px'], y=pitch_location_group['pz'],
+                    hue=pitch_location_group['pitch_type'], palette=dict_colour, ec='black',
+                    s=pitch_location_group['pitch_percent'] * 750, linewidth=2, zorder=2)
+
+    # Customize plot appearance
+    ax.axis('square')
+    draw_line(ax, alpha_spot=0.75, catcher_p=False)
+    ax.axis('off')
+    ax.set_xlim((-2.75, 2.75))
+    ax.set_ylim((-0.5, 5))
+    if len(pitch_location_group['px']) > 0:
+        ax.get_legend().remove()
+    ax.grid(False)
+    ax.set_title(f"Pitch Locations vs {hand}HB\n{pitch_location_group['pitches'].sum()} Pitches", fontdict=font_properties_titles)
+
+
+def summary_table(df: pl.DataFrame, ax: plt.Axes):
+    """
+    Create a summary table of pitch data.
+
+    Parameters
+    ----------
+    df : pl.DataFrame
+        The DataFrame containing pitch data.
+    ax : plt.Axes
+        The axis to plot the table on.
+    """
+    # Aggregate pitch data by pitch description
+    df_agg = df.group_by("pitch_description").agg(
+        pl.col('is_pitch').sum().alias('count'),
+        (pl.col('is_pitch').sum() / df.select(pl.col('is_pitch').sum())).alias('count_percent'),
+        pl.col('start_speed').mean().alias('start_speed'),
+        pl.col('ivb').mean().alias('ivb'),
+        pl.col('hb').mean().alias('hb'),
+        pl.col('spin_rate').mean().alias('spin_rate'),
+        pl.col('vaa').mean().alias('vaa'),
+        pl.col('haa').mean().alias('haa'),
+        pl.col('release_pos_z').mean().alias('z0'),
+        pl.col('release_pos_x').mean().alias('x0'),
+        pl.col('extension').mean().alias('extension'),
+        (((pl.col('spin_direction').mean() + 180) % 360 // 30) + 
+        (((pl.col('spin_direction').mean() + 180) % 360 % 30 / 30 / 100 * 60).round(2) * 10).round(0) // 1.5 / 4)
+        .cast(pl.Float64).map_elements(lambda x: f"{int(x)}:{int((x % 1) * 60):02d}", return_dtype=pl.Utf8).alias('clock_time'),
+        pl.col('tj_stuff_plus').mean().alias('tj_stuff_plus'),
+        pl.col('pitch_grade').mean().alias('pitch_grade'),
+        (pl.col('in_zone').sum() / pl.col('is_pitch').sum()).alias('zone_percent'),
+        (pl.col('ozone_swing').sum() / pl.col('out_zone').sum()).alias('chase_percent'),
+        (pl.col('whiffs').sum() / pl.col('swings').sum()).alias('whiff_percent'),
+        (pl.col('woba_pred_contact').sum() / pl.col('bip').sum()).alias('xwobacon')
+    ).sort("count", descending=True)
+
+    # Aggregate all pitch data
+    df_agg_all = df.group_by(pl.lit("All").alias("pitch_description")).agg(
+        pl.col('is_pitch').sum().alias('count'),
+        (pl.col('is_pitch').sum() / df.select(pl.col('is_pitch').sum())).alias('count_percent'),
+        pl.lit(None).alias('start_speed'),
+        pl.lit(None).alias('ivb'),
+        pl.lit(None).alias('hb'),
+        pl.lit(None).alias('spin_rate'),
+        pl.lit(None).alias('vaa'),
+        pl.lit(None).alias('haa'),
+        pl.lit(None).alias('z0'),
+        pl.lit(None).alias('x0'),
+        pl.col('extension').mean().alias('extension'),
+        pl.lit(None).alias('clock_time'),
+        pl.col('tj_stuff_plus').mean().alias('tj_stuff_plus'),
+        pl.lit(None).alias('pitch_grade'),
+        (pl.col('in_zone').sum() / pl.col('is_pitch').sum()).alias('zone_percent'),
+        (pl.col('ozone_swing').sum() / pl.col('out_zone').sum()).alias('chase_percent'),
+        (pl.col('whiffs').sum() / pl.col('swings').sum()).alias('whiff_percent'),
+        (pl.col('woba_pred_contact').sum() / pl.col('bip').sum()).alias('xwobacon')
+    )
+
+    # Concatenate aggregated data
+    df_agg = pl.concat([df_agg, df_agg_all]).fill_nan(None)
+
+    # Load statcast pitch summary data
+    statcast_pitch_summary = pl.read_csv('functions/statcast_2024_grouped.csv')
+
+    # Create table
+    table = ax.table(cellText=df_agg.fill_nan('—').fill_null('—').to_numpy(), colLabels=df_agg.columns, cellLoc='center',
+                     colWidths=[2.3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], bbox=[0.0, 0, 1, 0.8])
+
+    # Set table properties
+    min_font_size = 14
+    table.auto_set_font_size(False)
+    table.set_fontsize(min_font_size)
+    table.scale(1, 0.5)
+
+    # Set font size for values
+    min_font_size = 18
+    for i in range(len(df_agg) + 1):
+        for j in range(len(df_agg.columns)):
+            if i > 0:  # Skip the header row
+                cell = table.get_celld()[i, j]
+                cell.set_fontsize(min_font_size)
+
+    # Define color maps
+    cmap_sum = mcolors.LinearSegmentedColormap.from_list("", ['#648FFF', '#FFFFFF', '#FFB000'])
+    cmap_sum_r = mcolors.LinearSegmentedColormap.from_list("", ['#FFB000', '#FFFFFF', '#648FFF'])
+
+    # Update table cells with colors and text properties
+    for i in range(len(df_agg)):
+        pitch_check = dict_pitch_desc_type[df_agg['pitch_description'][i]]
+        cell_text = table.get_celld()[(i + 1, 0)].get_text().get_text()
+
+        if cell_text != 'All':
+            table.get_celld()[(i + 1, 0)].set_facecolor(dict_pitch_name[cell_text])
+            text_props = {'color': '#000000', 'fontweight': 'bold'} if cell_text in ['Split-Finger', 'Slider', 'Changeup'] else {'color': '#ffffff', 'fontweight': 'bold'}
+            table.get_celld()[(i + 1, 0)].set_text_props(**text_props)
+            if cell_text == 'Four-Seam Fastball':
+                table.get_celld()[(i + 1, 0)].get_text().set_text('4-Seam')
+
+        select_df = statcast_pitch_summary.filter(statcast_pitch_summary['pitch_type'] == pitch_check)
+
+        # Apply color to specific columns based on normalized values
+        columns_to_color = [(3, 'release_speed', 0.95, 1.05), (11, 'release_extension', 0.9, 1.1), (13, None, 80, 120), 
+                            (14, None, 30, 70), (15, 'in_zone_rate', 0.7, 1.3), (16, 'chase_rate', 0.7, 1.3), 
+                            (17, 'whiff_rate', 0.7, 1.3), (18, 'xwobacon', 0.7, 1.3)]
+
+        for col, stat, vmin_factor, vmax_factor in columns_to_color:
+            cell_value = table.get_celld()[(i + 1, col)].get_text().get_text()
+            if cell_value != '—':
+                vmin = select_df[stat].mean() * vmin_factor if stat else vmin_factor
+                vmax = select_df[stat].mean() * vmax_factor if stat else vmax_factor
+                normalize = mcolors.Normalize(vmin=vmin, vmax=vmax)
+                cmap = cmap_sum if col != 18 else cmap_sum_r
+                table.get_celld()[(i + 1, col)].set_facecolor(get_color(float(cell_value.strip('%')), normalize, cmap))
+
+    # Set header text properties
+    table.get_celld()[(len(df_agg), 0)].set_text_props(color='#000000', fontweight='bold')
+
+    # Update column names
+    new_column_names = ['$\\bf{Pitch\\ Name}$', '$\\bf{Count}$', '$\\bf{Pitch\\%}$', '$\\bf{Velocity}$', '$\\bf{iVB}$', 
+                        '$\\bf{HB}$', '$\\bf{Spin}$', '$\\bf{VAA}$', '$\\bf{HAA}$', '$\\bf{vRel}$', '$\\bf{hRel}$', 
+                        '$\\bf{Ext.}$', '$\\bf{Axis}$', '$\\bf{tjStuff+}$', '$\\bf{Grade}$', '$\\bf{Zone\\%}$', 
+                        '$\\bf{Chase\\%}$', '$\\bf{Whiff\\%}$', '$\\bf{xwOBA}$\n$\\bf{Contact}$']
+
+    for i, col_name in enumerate(new_column_names):
+        table.get_celld()[(0, i)].get_text().set_text(col_name)
+
+    # Format cell values
+    def format_cells(columns, fmt):
+        for col in columns:
+            col_idx = df_agg.columns.index(col)
+            for row in range(1, len(df_agg) + 1):
+                cell_value = table.get_celld()[(row, col_idx)].get_text().get_text()
+                if cell_value != '—':
+                    table.get_celld()[(row, col_idx)].get_text().set_text(fmt.format(float(cell_value.strip('%'))))
+
+    format_cells(['start_speed', 'ivb', 'hb', 'vaa', 'haa', 'z0', 'x0', 'extension'], '{:,.1f}')
+    format_cells(['xwobacon'], '{:,.3f}')
+    format_cells(['count_percent', 'zone_percent', 'chase_percent', 'whiff_percent'], '{:,.1%}')
+    format_cells(['tj_stuff_plus', 'pitch_grade', 'spin_rate'], '{:,.0f}')
+
+    # Create legend for pitch types
+    items_in_order = (df.sort("pitch_count", descending=True)['pitch_type'].unique(maintain_order=True).to_numpy())
+    colour_pitches = [dict_colour[x] for x in items_in_order]
+    label = [dict_pitch[x] for x in items_in_order]
+    handles = [plt.scatter([], [], color=color, marker='o', s=100) for color in colour_pitches]
+    if len(label) > 5:
+        ax.legend(handles, label, bbox_to_anchor=(0.1, 0.81, 0.8, 0.14), ncol=5,
+                  fancybox=True, loc='lower center', fontsize=16, framealpha=1.0, markerscale=1.7, prop={'family': 'calibi', 'size': 16})
+    else:
+        ax.legend(handles, label, bbox_to_anchor=(0.1, 0.81, 0.8, 0.14), ncol=5,
+                  fancybox=True, loc='lower center', fontsize=20, framealpha=1.0, markerscale=2, prop={'family': 'calibi', 'size': 20})
+    ax.axis('off')
+
+def plot_footer(ax: plt.Axes):
+    """
+    Add footer text to the plot.
+
+    Parameters
+    ----------
+    ax : plt.Axes
+        The axis to add the footer text to.
+    """
+    # Add footer text
+    ax.text(0, 1, 'By: @TJStats', ha='left', va='top', fontsize=24)
+    ax.text(0.5, 0.25, 
+            '''
+            Colour Coding Compares to League Average By Pitch
+            tjStuff+ calculates the Expected Run Value (xRV) of a pitch regardless of type
+            tjStuff+ is normally distributed, where 100 is the mean and Standard Deviation is 10
+            Pitch Grade scales tjStuff+ to the traditional 20-80 Scouting Scale for a given pitch type
+            ''', 
+            ha='center', va='bottom', fontsize=12)
+    ax.text(1, 1, 'Data: MLB, Fangraphs\nImages: MLB, ESPN', ha='right', va='top', fontsize=24)
+    ax.axis('off')
+
+# Function to get an image from a URL and display it on the given axis
+def player_headshot(player_input: str, ax: plt.Axes, sport_id: int, season: int):
+    """
+    Display the player's headshot image on the given axis.
+
+    Parameters
+    ----------
+    player_input : str
+        The player's ID.
+    ax : plt.Axes
+        The axis to display the image on.
+    sport_id : int
+        The sport ID (1 for MLB, other for minor leagues).
+    season : int
+        The season year.
+    """
+    try:
+        # Construct the URL for the player's headshot image based on sport ID
+        if int(sport_id) == 1:
+            url = f'https://img.mlbstatic.com/mlb-photos/image/upload/d_people:generic:headshot:67:current.png/w_640,q_auto:best/v1/people/{player_input}/headshot/silo/current.png'
+        else:
+            url = f'https://img.mlbstatic.com/mlb-photos/image/upload/c_fill,g_auto/w_640/v1/people/{player_input}/headshot/milb/current.png'
+
+        # Send a GET request to the URL and open the image from the response content
+        response = requests.get(url)
+        img = Image.open(BytesIO(response.content))
+
+        # Display the image on the axis
+        ax.set_xlim(0, 1.3)
+        ax.set_ylim(0, 1)
+        ax.imshow(img, extent=[0, 1, 0, 1] if sport_id == 1 else [1/6, 5/6, 0, 1], origin='upper')
+    except PIL.UnidentifiedImageError:
+        ax.axis('off')
+        return
+
+    # Turn off the axis
+    ax.axis('off')
+
+def player_bio(pitcher_id: str, ax: plt.Axes, sport_id: int, year_input: int):
+    """
+    Display the player's bio information on the given axis.
+
+    Parameters
+    ----------
+    pitcher_id : str
+        The player's ID.
+    ax : plt.Axes
+        The axis to display the bio information on.
+    sport_id : int
+        The sport ID (1 for MLB, other for minor leagues).
+    year_input : int
+        The season year.
+    """
+    # Construct the URL to fetch player data
+    url = f"https://statsapi.mlb.com/api/v1/people?personIds={pitcher_id}&hydrate=currentTeam"
+
+    # Send a GET request to the URL and parse the JSON response
+    data = requests.get(url).json()
+
+    # Extract player information from the JSON data
+    player_name = data['people'][0]['fullName']
+    pitcher_hand = data['people'][0]['pitchHand']['code']
+    age = data['people'][0]['currentAge']
+    height = data['people'][0]['height']
+    weight = data['people'][0]['weight']
+
+    # Display the player's name, handedness, age, height, and weight on the axis
+    ax.text(0.5, 1, f'{player_name}', va='top', ha='center', fontsize=56)
+    ax.text(0.5, 0.7, f'{pitcher_hand}HP, Age: {age}, {height}/{weight}', va='top', ha='center', fontsize=30)
+    ax.text(0.5, 0.45, f'Season Pitching Summary', va='top', ha='center', fontsize=40)
+
+    # Make API call to retrieve sports information
+    response = requests.get(url='https://statsapi.mlb.com/api/v1/sports').json()
+    
+    # Convert the JSON response into a Polars DataFrame
+    df_sport_id = pl.DataFrame(response['sports'])    
+    abb = df_sport_id.filter(pl.col('id') == sport_id)['abbreviation'][0]
+
+    # Display the season and sport abbreviation
+    ax.text(0.5, 0.20, f'{year_input} {abb} Season', va='top', ha='center', fontsize=30, fontstyle='italic')
+
+    # Turn off the axis
+    ax.axis('off')
+
+def plot_logo(pitcher_id: str, ax: plt.Axes, df_team: pl.DataFrame, df_players: pl.DataFrame):
+    """
+    Display the team logo for the given pitcher on the specified axis.
+
+    Parameters
+    ----------
+    pitcher_id : str
+        The ID of the pitcher.
+    ax : plt.Axes
+        The axis to display the logo on.
+    df_team : pl.DataFrame
+        The DataFrame containing team data.
+    df_players : pl.DataFrame
+        The DataFrame containing player data.
+    """
+    # List of MLB teams and their corresponding ESPN logo URLs
+    mlb_teams = [
+        {"team": "AZ", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/ari.png&h=500&w=500"},
+        {"team": "ATL", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/atl.png&h=500&w=500"},
+        {"team": "BAL", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/bal.png&h=500&w=500"},
+        {"team": "BOS", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/bos.png&h=500&w=500"},
+        {"team": "CHC", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/chc.png&h=500&w=500"},
+        {"team": "CWS", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/chw.png&h=500&w=500"},
+        {"team": "CIN", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/cin.png&h=500&w=500"},
+        {"team": "CLE", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/cle.png&h=500&w=500"},
+        {"team": "COL", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/col.png&h=500&w=500"},
+        {"team": "DET", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/det.png&h=500&w=500"},
+        {"team": "HOU", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/hou.png&h=500&w=500"},
+        {"team": "KC", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/kc.png&h=500&w=500"},
+        {"team": "LAA", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/laa.png&h=500&w=500"},
+        {"team": "LAD", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/lad.png&h=500&w=500"},
+        {"team": "MIA", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/mia.png&h=500&w=500"},
+        {"team": "MIL", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/mil.png&h=500&w=500"},
+        {"team": "MIN", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/min.png&h=500&w=500"},
+        {"team": "NYM", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/nym.png&h=500&w=500"},
+        {"team": "NYY", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/nyy.png&h=500&w=500"},
+        {"team": "OAK", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/oak.png&h=500&w=500"},
+        {"team": "PHI", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/phi.png&h=500&w=500"},
+        {"team": "PIT", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/pit.png&h=500&w=500"},
+        {"team": "SD", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/sd.png&h=500&w=500"},
+        {"team": "SF", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/sf.png&h=500&w=500"},
+        {"team": "SEA", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/sea.png&h=500&w=500"},
+        {"team": "STL", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/stl.png&h=500&w=500"},
+        {"team": "TB", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/tb.png&h=500&w=500"},
+        {"team": "TEX", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/tex.png&h=500&w=500"},
+        {"team": "TOR", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/tor.png&h=500&w=500"},
+        {"team": "WSH", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/wsh.png&h=500&w=500"},
+        {"team": "ATH", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/oak.png&h=500&w=500"},
+    ]
+
+    try:
+        # Create a DataFrame from the list of dictionaries
+        df_image = pd.DataFrame(mlb_teams)
+        image_dict = df_image.set_index('team')['logo_url'].to_dict()
+
+        # Get the team ID for the given pitcher
+        team_id = df_players.filter(pl.col('player_id') == pitcher_id)['team'][0]
+
+        # Construct the URL to fetch team data
+        url_team = f'https://statsapi.mlb.com/api/v1/teams/{team_id}'
+
+        # Send a GET request to the team URL and parse the JSON response
+        data_team = requests.get(url_team).json()
+
+        # Extract the team abbreviation
+        if data_team['teams'][0]['id'] in df_team['parent_org_id']:
+            team_abb = df_team.filter(pl.col('team_id') == data_team['teams'][0]['id'])['parent_org_abbreviation'][0]
+        else:
+            team_abb = df_team.filter(pl.col('parent_org_id') == data_team['teams'][0]['parentOrgId'])['parent_org_abbreviation'][0]
+
+        # Get the logo URL from the image dictionary using the team abbreviation
+        logo_url = image_dict[team_abb]
+
+        # Send a GET request to the logo URL
+        response = requests.get(logo_url)
+
+        # Open the image from the response content
+        img = Image.open(BytesIO(response.content))
+
+        # Display the image on the axis
+        ax.set_xlim(0, 1.3)
+        ax.set_ylim(0, 1)
+        ax.imshow(img, extent=[0.3, 1.3, 0, 1], origin='upper')
+
+        # Turn off the axis
+        ax.axis('off')
+    except (KeyError,IndexError) as e:
+        ax.axis('off')
+        return
+
+splits = {
+    'all':0,
+    'left':13,
+    'right':14,
+}
+
+splits_title = {
+
+    'all':'',
+    'left':' vs LHH',
+    'right':' vs RHH',
+
+}
+
+
+def fangraphs_pitching_leaderboards(season: int,
+                                    split: str,
+                                    start_date: str = '2024-01-01',
+                                    end_date: str = '2024-12-31'):
+    """
+    Fetch pitching leaderboards data from Fangraphs.
+
+    Parameters
+    ----------
+    season : int
+        The season year.
+    split : str
+        The split type (e.g., 'All', 'LHH', 'RHH').
+    start_date : str, optional
+        The start date for the data (default is '2024-01-01').
+    end_date : str, optional
+        The end date for the data (default is '2024-12-31').
+
+    Returns
+    -------
+    pl.DataFrame
+        The DataFrame containing the pitching leaderboards data.
+    """
+    url = f"""
+           https://www.fangraphs.com/api/leaders/major-league/data?age=&pos=all&stats=pit&lg=all&season={season}&season1={season}
+           &startdate={start_date}&enddate={end_date}&ind=0&qual=0&type=8&month=1000&pageitems=500000
+           """
+
+    data = requests.get(url).json()
+    df = pl.DataFrame(data=data['data'], infer_schema_length=1000)
+    return df
+
+def fangraphs_splits_scrape(player_input: str, year_input: int, start_date: str, end_date: str, split: str) -> pl.DataFrame:
+    """
+    Scrape Fangraphs splits data for a specific player.
+
+    Parameters
+    ----------
+    player_input : str
+        The player's ID.
+    year_input : int
+        The season year.
+    start_date : str
+        The start date for the data.
+    end_date : str
+        The end date for the data.
+    split : str
+        The split type (e.g., 'all', 'left', 'right').
+
+    Returns
+    -------
+    pl.DataFrame
+        The DataFrame containing the splits data.
+    """
+    split_dict = {
+        'all': [],
+        'left': ['5'],
+        'right': ['6']
+    }
+
+    
+
+    url = "https://www.fangraphs.com/api/leaders/splits/splits-leaders"
+
+    # Get Fangraphs player ID
+    fg_id = str(fangraphs_pitching_leaderboards(
+        year_input,
+        split='All',
+        start_date=f'{year_input}-01-01',
+        end_date=f'{year_input}-12-31'
+    ).filter(pl.col('xMLBAMID') == player_input)['playerid'][0])
+
+    # Payload for basic stats
+    payload = {
+        "strPlayerId": fg_id,
+        "strSplitArr": split_dict[split],
+        "strGroup": "season",
+        "strPosition": "P",
+        "strType": "2",
+        "strStartDate": pd.to_datetime(start_date).strftime('%Y-%m-%d'),
+        "strEndDate": pd.to_datetime(end_date).strftime('%Y-%m-%d'),
+        "strSplitTeams": False,
+        "dctFilters": [],
+        "strStatType": "player",
+        "strAutoPt": False,
+        "arrPlayerId": [],
+        "strSplitArrPitch": [],
+        "arrWxTemperature": None,
+        "arrWxPressure": None,
+        "arrWxAirDensity": None,
+        "arrWxElevation": None,
+        "arrWxWindSpeed": None
+    }
+
+    # Fetch basic stats
+    response = requests.post(url, data=json.dumps(payload), headers={'Content-Type': 'application/json'})
+    data_pull = response.json()['data'][0]
+
+    # Payload for advanced stats
+    payload_advanced = payload.copy()
+    payload_advanced["strType"] = "1"
+
+    # Fetch advanced stats
+    response_advanced = requests.post(url, data=json.dumps(payload_advanced), headers={'Content-Type': 'application/json'})
+    data_pull_advanced = response_advanced.json()['data'][0]
+
+    # Combine basic and advanced stats
+    data_pull.update(data_pull_advanced)
+    df_pull = pl.DataFrame(data_pull)
+
+    return df_pull
+
+                                   
+def fangraphs_table(df: pl.DataFrame,
+                    ax: plt.Axes,
+                    player_input: str,
+                    season: int,
+                    split: str):
+    """
+    Create a table of Fangraphs pitching leaderboards data for a specific player.
+
+    Parameters
+    ----------
+    ax : plt.Axes
+        The axis to plot the table on.
+    season : int
+        The season year.
+    split : str
+        The split type (e.g., 'All', 'LHH', 'RHH').
+    """
+
+    start_date = df['game_date'][0]
+    end_date = df['game_date'][-1]
+
+    # Fetch Fangraphs splits data
+    df_fangraphs = fangraphs_splits_scrape(player_input=player_input, 
+                                           year_input=season,
+                                           start_date=start_date,
+                                           end_date=end_date,
+                                           split=split)
+
+    # Select relevant columns for the table
+    plot_table = df_fangraphs.select(['IP', 'WHIP', 'ERA', 'TBF', 'FIP', 'K%', 'BB%', 'K-BB%'])
+
+    # Format table values
+    plot_table_values = [format(plot_table[x][0], fangraphs_stats_dict[x]['format']) if plot_table[x][0] != '---' else '---' for x in plot_table.columns]
+    
+    # Create the table
+    table_fg = ax.table(cellText=[plot_table_values], colLabels=plot_table.columns, cellLoc='center',
+                        bbox=[0.0, 0.1, 1, 0.7])
+
+    # Set font size for the table
+    min_font_size = 20
+    table_fg.set_fontsize(min_font_size)
+
+    # Update column names with formatted headers
+    new_column_names = [fangraphs_stats_dict[col]['table_header'] for col in plot_table.columns]
+    for i, col_name in enumerate(new_column_names):
+        table_fg.get_celld()[(0, i)].get_text().set_text(col_name)
+
+    # Set header text properties
+    ax.text(0.5, 0.9, f'{start_date} to {end_date}{splits_title[split]}', va='bottom', ha='center',
+            fontsize=36, fontstyle='italic')
+    ax.axis('off')
+
+
+def stat_summary_table(df: pl.DataFrame, 
+                        player_input: int, 
+                        sport_id: int, 
+                        ax: plt.Axes,
+                        split: str = 'All',
+                        game_type: list = ['R']):
+    """
+    Create a summary table of player statistics.
+
+    Parameters
+    ----------
+    df : pl.DataFrame
+        The DataFrame containing pitch data.
+    player_input : int
+        The player's ID.
+    sport_id : int
+        The sport ID (1 for MLB, other for minor leagues).
+    ax : plt.Axes
+        The axis to plot the table on.
+    split : str, optional
+        The split type (default is 'All').
+    """
+
+    type_dict =  {'R':'Regular Season',
+                   'S':'Spring',
+                   'P':'Playoffs' }
+
+    split_title = {
+        'all':'',
+        'right':' vs RHH',
+        'left':' vs LHH'
+    }
+
+    
+    # Format start and end dates
+    start_date_format = str(pd.to_datetime(df['game_date'][0]).strftime('%m/%d/%Y'))
+    end_date_format = str(pd.to_datetime(df['game_date'][-1]).strftime('%m/%d/%Y'))
+
+    # Determine app context based on sport ID
+    appContext = 'majorLeague' if sport_id == 1 else 'minorLeague'
+
+    game_type_str = ','.join([str(x) for x in game_type])
+
+    # Fetch player stats from MLB API
+    pitcher_stats_call = requests.get(
+        f'https://statsapi.mlb.com/api/v1/people/{player_input}?appContext={appContext}&hydrate=stats(group=[pitching],type=[byDateRange],sportId={sport_id},startDate={start_date_format},endDate={end_date_format},gameType=[{game_type_str}])'
+    ).json()
+    print('HERE')
+    print(f'https://statsapi.mlb.com/api/v1/people/{player_input}?appContext={appContext}&hydrate=stats(group=[pitching],type=[byDateRange],sportId={sport_id},startDate={start_date_format},endDate={end_date_format},gameType=[{game_type_str}])')
+    # Extract stats and create DataFrame
+    pitcher_stats_call_header = [x for x in pitcher_stats_call['people'][0]['stats'][0]['splits'][-1]['stat']]
+    pitcher_stats_call_values = [pitcher_stats_call['people'][0]['stats'][0]['splits'][-1]['stat'][x] for x in pitcher_stats_call['people'][0]['stats'][0]['splits'][-1]['stat']]
+    pitcher_stats_call_df = pl.DataFrame(data=dict(zip(pitcher_stats_call_header, pitcher_stats_call_values)))
+
+    # Add additional calculated columns
+    pitcher_stats_call_df = pitcher_stats_call_df.with_columns(
+        pl.lit(df['is_whiff'].sum()).alias('whiffs'),
+        (pl.col('strikeOuts') / pl.col('battersFaced') * 100).round(1).cast(pl.Utf8).str.concat('%').alias('k_percent'),
+        (pl.col('baseOnBalls') / pl.col('battersFaced') * 100).round(1).cast(pl.Utf8).str.concat('%').alias('bb_percent'),
+        ((pl.col('strikeOuts') - pl.col('baseOnBalls')) / pl.col('battersFaced') * 100).round(1).cast(pl.Utf8).str.concat('%').alias('k_bb_percent'),
+        (((pl.col('homeRuns') * 13 + 3 * ((pl.col('baseOnBalls')) + (pl.col('hitByPitch'))) - 2 * (pl.col('strikeOuts')))) / ((pl.col('outs')) / 3) + 3.15).round(2).map_elements(lambda x: f"{x:.2f}").alias('fip'),
+        ((pl.col('strikes') / pl.col('numberOfPitches') * 100)).round(1).cast(pl.Utf8).str.concat('%').alias('strikePercentage'),
+    )
+
+    # Determine columns and title based on game count and sport ID
+    if df['game_id'][0] == df['game_id'][-1]:
+        pitcher_stats_call_df_small = pitcher_stats_call_df.select(['inningsPitched', 'battersFaced', 'earnedRuns', 'hits', 'strikeOuts', 'baseOnBalls', 'hitByPitch', 'homeRuns', 'strikePercentage', 'whiffs'])
+        new_column_names = ['$\\bf{IP}$', '$\\bf{PA}$', '$\\bf{ER}$', '$\\bf{H}$', '$\\bf{K}$', '$\\bf{BB}$', '$\\bf{HBP}$', '$\\bf{HR}$', '$\\bf{Strike\%}$', '$\\bf{Whiffs}$']
+        title = f'{df["game_date"][0]} vs {df["batter_team"][0]} ({type_dict[game_type[0]]}){split_title[split]}'
+    elif sport_id != 1 or game_type[0] in ['S','P']:
+        pitcher_stats_call_df_small = pitcher_stats_call_df.select(['inningsPitched', 'battersFaced', 'whip', 'era', 'fip', 'k_percent', 'bb_percent', 'k_bb_percent', 'strikePercentage'])
+        new_column_names = ['$\\bf{IP}$', '$\\bf{PA}$', '$\\bf{WHIP}$', '$\\bf{ERA}$', '$\\bf{FIP}$', '$\\bf{K\%}$', '$\\bf{BB\%}$', '$\\bf{K-BB\%}$', '$\\bf{Strike\%}$']
+        title = f'{df["game_date"][0]} to {df["game_date"][-1]} ({type_dict[game_type[0]]}{split_title[split]})'
+    else:
+        fangraphs_table(df=df, ax=ax, player_input=player_input, season=int(df['game_date'][0][0:4]), split=split)
+        return
+
+    # Create and format the table
+    table_fg = ax.table(cellText=pitcher_stats_call_df_small.to_numpy(), colLabels=pitcher_stats_call_df_small.columns, cellLoc='center', bbox=[0.0, 0.1, 1, 0.7])
+    table_fg.set_fontsize(20)
+    for i, col_name in enumerate(new_column_names):
+        table_fg.get_celld()[(0, i)].get_text().set_text(col_name)
+
+    # Add title to the plot
+    ax.text(0.5, 0.9, title, va='bottom', ha='center', fontsize=36, fontstyle='italic')
+    ax.axis('off')

functions/statcast_2024_grouped.csv

@@ -0,0 +1,19 @@
+pitch_type,pitch,release_speed,pfx_z,pfx_x,release_spin_rate,release_pos_x,release_pos_z,release_extension,delta_run_exp,swing,whiff,in_zone,out_zone,chase,xwoba,xwobacon,pitch_usage,whiff_rate,in_zone_rate,chase_rate,delta_run_exp_per_100,all
+CH,74155,85.46226726,5.247514143,-3.974501168,1803.342541,-0.507762986,5.740925968,6.449406057,204.631,37385,11538,28912,45151,15250,0.289735649,0.341580895,0.102188463,0.308626454,0.389886049,0.337755531,-0.275950374,
+CS,22,66.38181818,-7.232727273,5.176363636,2039.272727,-1.798181818,6.517727273,6.063636364,-0.629,9,2,10,12,2,0.134666667,0.1945,3.03E-05,0.222222222,0.454545455,0.166666667,2.859090909,
+CU,47579,79.40938533,-9.345106446,4.516206279,2568.859105,-0.676571206,5.943843838,6.401792909,93.572,19910,6150,20751,26738,7749,0.280497676,0.36671832,0.065565706,0.308890005,0.436137792,0.289812252,-0.196666597,
+EP,576,50.51909722,16.35729167,-3.82875,1256.715278,-0.966875,6.647100694,4.442013889,23.643,252,7,207,369,106,0.39714307,0.361505495,0.00079375,0.027777778,0.359375,0.287262873,-4.1046875,
+FA,635,67.81354331,15.86551181,-3.722645669,1674.014469,-1.116377953,6.317716535,4.92488189,15.495,284,29,296,339,73,0.43393491,0.388761905,0.000875055,0.102112676,0.466141732,0.215339233,-2.44015748,
+FC,58379,89.56435814,8.088953962,1.55092437,2389.231716,-0.974536268,5.8461769,6.403954997,-20.39,28753,6674,30002,28189,7757,0.340778229,0.370073593,0.080448524,0.23211491,0.513917676,0.275178261,0.034926943,
+FF,230412,94.27369496,15.72027483,-3.107441897,2296.59179,-0.768543293,5.821400777,6.524392111,-80.284,113157,24741,127386,102722,24808,0.340125691,0.388167436,0.317516664,0.218643124,0.55286183,0.241506201,0.034843671,
+FO,168,82.07916667,1.735714286,0.137857143,946.8154762,-0.533333333,5.891428571,6.666666667,2.539,89,29,60,108,43,0.277987474,0.3952,0.000231511,0.325842697,0.357142857,0.398148148,-1.511309524,
+FS,21727,86.31228886,2.979608782,-8.765506513,1302.399298,-1.464082478,5.742066553,6.508958525,-16.641,11333,3906,7982,13745,4946,0.254878506,0.344396607,0.029940648,0.344657196,0.367376996,0.359839942,0.076591338,
+KC,11916,81.79965592,-9.370896274,4.89529708,2444.16428,-0.878808325,5.940037764,6.434007554,-12.997,5312,1860,4858,7058,2316,0.258451373,0.364636161,0.01642071,0.350150602,0.407687143,0.328138283,0.109071836,
+KN,971,76.94819773,-2.945375901,-5.356498455,263.5632699,-1.230339856,5.542131823,6.45653965,12.681,426,113,428,543,130,0.287038918,0.369510345,0.001338076,0.265258216,0.440782698,0.239410681,-1.305973223,
+PO,55,91.24909091,13.11709091,-6.399272727,2195.381818,-1.494181818,5.861272727,6.305454545,0,0,0,1,54,0,,,7.58E-05,,0.018181818,0,0,
+SC,159,81.02264151,-3.105660377,-8.001509434,2050.597484,-1.053584906,6.110377358,6.064150943,4.623,58,13,63,96,20,0.353494636,0.413142857,0.000219108,0.224137931,0.396226415,0.208333333,-2.90754717,
+SI,116002,93.34805382,7.567078832,-6.14847607,2147.36315,-0.767198351,5.622119363,6.435364206,-32.837,53318,7390,65492,50222,12474,0.350196742,0.364144629,0.159855251,0.138602348,0.564576473,0.248377205,0.028307271,
+SL,116390,85.60138786,1.57598588,2.732511063,2435.570552,-0.981103401,5.761407576,6.433055359,-167.415,56606,19101,52478,63672,20396,0.281860701,0.357665208,0.16038993,0.337437727,0.45088066,0.320329187,0.143839677,
+ST,43821,81.85801556,1.479693298,7.821825152,2575.366192,-1.080187125,5.460724082,6.403526748,-52.968,20035,6276,19349,24472,7531,0.259780708,0.337221732,0.060387036,0.313251809,0.441546291,0.307739457,0.120873554,
+SV,2702,81.67483346,-4.788941525,7.356861584,2470.624859,-0.577957069,5.420762398,6.227296393,0.193,1117,339,1138,1564,479,0.290768371,0.374640553,0.003723461,0.303491495,0.421169504,0.306265985,-0.007142857,
+All,725669,89.15210527,7.058379139,-1.214008754,2255.676825,-0.828252978,5.758824349,6.456550519,-20.178,352163,89742,359413,365054,104080,0.314703752,0.366398,1,0.25483086,0.49528504,0.285108504,0.002780607,all