Upload 4 files

app.py

@@ -0,0 +1,708 @@
+import pandas as pd
+import numpy as np
+import requests
+import math
+import matplotlib.pyplot as plt
+import seaborn as sns
+import matplotlib.patches as patches
+import matplotlib.colors as mcolors
+import matplotlib
+import inflect
+infl = inflect.engine()
+from matplotlib.offsetbox import (OffsetImage, AnnotationBbox)
+from matplotlib.colors import Normalize
+from matplotlib.ticker import FuncFormatter
+import matplotlib.ticker as mtick
+from matplotlib.colors import Normalize
+import urllib
+import urllib.request
+import urllib.error
+from urllib.error import HTTPError
+import time
+from shinywidgets import output_widget, render_widget
+import shinyswatch
+from shiny import App, Inputs, Outputs, Session, reactive, render, req, ui
+
+column_list = ['woba_percent',
+ 'xwoba_percent',
+ 'barrel_percent',
+ 'sweet_spot_percent',
+ 'hard_hit_percent',
+ 'launch_speed',
+ 'launch_speed_90',
+ 'max_launch_speed',
+ 'k_percent',
+ 'bb_percent',
+ 'swing_percent',
+ 'whiff_rate',
+ 'zone_swing_percent',
+ 'zone_contact_percent',
+ 'chase_percent',
+ 'chase_contact']
+column_list_pitch = ['pitches','bip','xwoba_percent','whiff_rate','chase_percent']
+
+import joblib
+
+
+loaded_model = joblib.load('joblib_model/barrel_model.joblib')
+in_zone_model = joblib.load('joblib_model/in_zone_model_knn_20240410.joblib')
+
+stat_plot_dict =   {'woba_percent':{'name':'wOBA','format':'.3f','flip':False},
+                    'xwoba_percent':{'name':'xwOBA','format':'.3f','flip':False},
+                    'woba_percent_contact':{'name':'wOBACON','format':'.3f','flip':False},
+                    'barrel_percent':{'name':'Barrel%','format':'.1%','flip':False},
+                    'max_launch_speed':{'name':'Max EV','format':'.1f','flip':False},
+                    'launch_speed_90':{'name':'90th% EV','format':'.1f','flip':False},
+                    'launch_speed':{'name':'Avg EV','format':'.1f','flip':False},
+                    'sweet_spot_percent':{'name':'SwSpot%','format':'.1%','flip':False},
+                    'hard_hit_percent':{'name':'HardHit%','format':'.1%','flip':False},
+                    'k_percent':{'name':'K%','format':'.1%','flip':True},
+                    'bb_percent':{'name':'BB%','format':'.1%','flip':False},
+                    'zone_contact_percent':{'name':'Z-Contact%','format':'.1%','flip':False},
+                    'zone_swing_percent':{'name':'Z-Swing%','format':'.1%','flip':False},
+                    'zone_percent':{'name':'Zone%','format':'.1%','flip':False},
+                    'chase_percent':{'name':'O-Swing%','format':'.1%','flip':True},
+                    'chase_contact':{'name':'O-Contact%','format':'.1%','flip':False},
+                    'swing_percent':{'name':'Swing%','format':'.1%','flip':False},
+                    'whiff_rate':{'name':'Whiff%','format':'.1%','flip':True},
+                    'bip':{'name':'Balls in Play','format':'.0f','flip':False},
+                    'pitches':{'name':'Pitches','format':'.0f','flip':False},}
+
+stat_plot_dict_rolling =   {'woba_percent':{'name':'wOBA','format':'.3f','flip':False,'y':'woba','div':'woba_codes','y_min':0.2,'y_max':0.6,'x_label':'wOBA PA','form':'3f'},
+                            'xwoba_percent':{'name':'xwOBA','format':'.3f','flip':False,'y':'xwoba','div':'woba_codes','y_min':0.2,'y_max':0.6,'x_label':'xwOBA PA','form':'3f'},
+                            'k_percent':{'name':'K%','format':'.1%','flip':True,'y':'k','div':'pa','y_min':0.0,'y_max':0.4,'x_label':'PA','form':'1%'},
+                            'bb_percent':{'name':'BB%','format':'.1%','flip':False,'y':'bb','div':'pa','y_min':0.0,'y_max':0.3,'x_label':'PA','form':'1%'},
+                            'zone_contact_percent':{'name':'Z-Contact%','format':'.1%','flip':False,'y':'zone_contact','div':'zone_swing','y_min':0.6,'y_max':1.0,'x_label':'In-Zone Swings','form':'1%'},
+                            'zone_swing_percent':{'name':'Z-Swing%','format':'.1%','flip':False,'y':'zone_swing','div':'in_zone','y_min':0.5,'y_max':1.0,'x_label':'In-Zone Pitches','form':'1%'},
+                            'zone_percent':{'name':'Zone%','format':'.1%','flip':False,'y':'in_zone','div':'pitches','y_min':0.3,'y_max':0.7,'x_label':'Pitches','form':'1%'},
+                            'chase_percent':{'name':'O-Swing%','format':'.1%','flip':True,'y':'ozone_swing','div':'out_zone','y_min':0.1,'y_max':0.4,'x_label':'Out-of-Zone Pitches','form':'1%'},
+                            'chase_contact':{'name':'O-Contact%','format':'.1%','flip':False,'y':'ozone_contact','div':'ozone_swing','y_min':0.4,'y_max':0.8,'x_label':'Out-of-Zone Swings','form':'1%'},
+                            'swing_percent':{'name':'Swing%','format':'.1%','flip':False,'y':'swings','div':'pitches','y_min':0.3,'y_max':0.7,'x_label':'Pitches','form':'1%'},
+                            'whiff_rate':{'name':'Whiff%','format':'.1%','flip':True,'y':'whiffs','div':'swings','y_min':0.0,'y_max':0.5,'x_label':'Swings','form':'1%'},}
+
+cmap_sum = matplotlib.colors.LinearSegmentedColormap.from_list("", ["#0C7BDC","#FFFFFF","#FFB000"])
+cmap_sum_r = matplotlib.colors.LinearSegmentedColormap.from_list("", ["#FFB000","#FFFFFF","#0C7BDC",])
+cmap_sum.set_bad(color='#C7C7C7', alpha=1.0)
+cmap_sum_r.set_bad(color='#C7C7C7', alpha=1.0)
+
+from batting_update import df_update,df_update_summ_avg,df_update_summ,df_summ_batter_pitch_up,df_summ_changes,df_summ_filter_out
+
+def percentile(n):
+    def percentile_(x):
+        return np.nanpercentile(x, n)
+    percentile_.__name__ = 'percentile_%s' % n
+    return percentile_
+
+print('Reading A')
+### Import Datasets
+from datasets import load_dataset
+dataset = load_dataset('nesticot/mlb_data', data_files=['mlb_pitch_data_2024.csv' ])
+dataset_train = dataset['train']
+df_a = dataset_train.to_pandas().set_index(list(dataset_train.features.keys())[0]).reset_index(drop=True)
+
+
+sport_id_input = 1
+
+
+print('Reading A')
+df_a_update = df_update(df_a)
+
+
+#df_a_update['batter_id'] = df_a_update['batter_id'].astype(int)
+df_a_update['batter_name'] = df_a_update['batter_name'].str.strip(' ')
+
+df_a_update['bip'] = df_a_update['bip'].replace({'0':False,'False':False,'True':True})
+
+
+choices_woba = [0.696,
+                    0.726,
+                    0.883,
+                    1.244,
+                    1.569,
+                    2.004]
+
+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']
+
+
+
+df_a_update['bip_div'] = ~df_a_update.launch_speed.isna()
+
+# df_dom_update['bip_div'] = ~df_dom_update.launch_speed.isna()
+df_a_update['average'] = 'average'
+#df_dom_update['average'] = 'average'
+
+#df_u['is_pitch']
+
+df_summ_a_update = df_summ_changes(df_update_summ(df_a_update)).set_index(['batter_id','batter_name'])
+# df_summ_dom_update = df_summ_changes(df_update_summ(df_dom_update)).set_index(['batter_id','batter_name'])
+
+df_summ_avg_a_update = df_summ_changes(df_update_summ_avg(df_a_update)).set_index(['average'])
+# df_summ_avg_dom_update = df_summ_changes(df_update_summ_avg(df_dom_update)).set_index(['average'])
+
+stat_roll_dict = dict(zip(stat_plot_dict_rolling.keys(),
+    [stat_plot_dict_rolling[x]['name'] for x in stat_plot_dict_rolling]))
+
+df_a_update['batter_id'] = df_a_update['batter_id'].astype(float).astype(int)
+
+a_player_dict = df_a_update.drop_duplicates(
+    'batter_id')[['batter_id','batter_name']].sort_values(by='batter_name').set_index('batter_id').to_dict()['batter_name']
+# dom_player_dict = df_summ_dom_update.reset_index().drop_duplicates(
+#     'batter_id')[['batter_id','batter_name']].sort_values(by='batter_name').set_index('batter_id').to_dict()['batter_name']
+
+
+import api_scraper
+mlb_stats = api_scraper.MLB_Scrape()
+
+def get_color(value, vmin, vmax, cmap_name=cmap_sum):
+        # Normalize the value within the range [0, 1]
+        normalized_value = (value - vmin) / (vmax - vmin)
+
+        # Get the colormap
+        cmap = plt.get_cmap(cmap_name)
+
+        # Map the normalized value to a color in the colormap
+        color = cmap(normalized_value)
+
+        # Convert the color from RGBA to hexadecimal format
+        hex_color = mcolors.rgb2hex(color)
+
+        return hex_color
+
+def server(input, output, session):
+    @render.ui
+    def test():
+            # @reactive.Effect
+
+            
+        return ui.input_select("player_id", "Select Batter",a_player_dict,selectize=True)
+            # if input.my_tabs() == 'LIDOM':
+            #     return ui.input_select("player_id", "Select Batter",dom_player_dict,selectize=True)
+
+
+    @output                
+    @render.plot(alt="A Plot")
+    @reactive.event(input.go, ignore_none=False)
+    def a_plot():
+        ### Iniput data for the level
+        #time.sleep(2)
+        df_update = df_a_update.copy()
+        df_summ_update = df_summ_a_update.copy() 
+        df_summ_avg_update = df_summ_avg_a_update.copy() 
+        if len(input.player_id()) < 1:
+                fig, ax = plt.subplots(1,1,figsize=(10,10))
+                ax.text(s='Please Select a Batter',x=0.5,y=0.5, ha='center')
+                ax.axis('off')
+                return fig 
+
+
+        batter_select = int(input.player_id())
+        
+        df_roll = df_update[df_update['batter_id']==batter_select]
+        if len(df_roll) == 0:
+                fig, ax = plt.subplots(1,1,figsize=(10,10))
+                ax.text(s='Card is Generating',x=0.5,y=0.5, ha='center')
+                ax.axis('off')
+                return fig 
+        
+        df_summ_filter = df_summ_filter_out(df_summ=df_summ_update,batter_select = batter_select)[0]
+        df_summ_filter_pct = df_summ_filter_out(df_summ=df_summ_update,batter_select = batter_select)[1]
+        df_summ_player = df_summ_filter_out(df_summ=df_summ_update,batter_select = batter_select)[2]
+        df_summ_player_pct = df_summ_filter_out(df_summ=df_summ_update,batter_select = batter_select)[3]
+
+        df_summ_batter_pitch = df_summ_batter_pitch_up(df= df_update).set_index(['batter_id','batter_name','pitch_category'])
+
+
+        df_summ_batter_pitch_pct = df_summ_batter_pitch.loc[df_summ_filter.index.get_level_values(0)]
+        df_summ_batter_pitch_pct = df_summ_batter_pitch_pct[df_summ_batter_pitch_pct['pitches']>0]
+        df_summ_batter_pitch_pct_rank = df_summ_batter_pitch_pct.groupby(level='pitch_category').apply(lambda x: x.rank(pct=True)).xs(batter_select,level=0)
+
+        df_summ_batter_pitch_pct_rank['pitch_count'] = df_summ_batter_pitch_pct_rank.index.get_level_values(1).map(df_summ_batter_pitch.xs(batter_select,level=0).reset_index().set_index('pitch_category')['pitches'].to_dict())
+        df_summ_batter_pitch_pct_rank = df_summ_batter_pitch_pct_rank.sort_values('pitch_count',ascending=False)           
+        #df_summ_batter_pitch_pct_rank = df_summ_batter_pitch_pct_rank.dropna()
+
+
+
+        def rolling_plot(stat='k_percent',window_width=100,ax=0,df_r=df_roll,df_r_summ_avg=pd.DataFrame(),stat_plot_dict_rolling=stat_plot_dict_rolling):
+            plot = sns.lineplot(x=range(window_width,len(df_r[df_r[stat_plot_dict_rolling[stat]['div']]>0])+1),
+                        y=df_r[df_r[stat_plot_dict_rolling[stat]['div']]==1].fillna(0).rolling(window=window_width)[stat_plot_dict_rolling[stat]['y']].sum().dropna()/window_width,
+                        ax=ax,
+                        color="#FFB000",
+                        zorder=10)
+
+
+
+            # ["#0C7BDC","#FFFFFF","#FFB000"])
+            ax.set_xlim(window_width,len(df_r[df_r[stat_plot_dict_rolling[stat]['div']]==1]))
+            ax.set_xlabel(stat_plot_dict_rolling[stat]['x_label'],fontsize=8)
+            ax.set_ylabel(stat_plot_dict_rolling[stat]['name'],fontsize=8)
+
+            ax.hlines(df_r_summ_avg[stat_plot_dict_rolling[stat]['y']]/df_r_summ_avg[stat_plot_dict_rolling[stat]['div']],
+                        xmin=window_width,
+                        xmax=len(df_r[df_r[stat_plot_dict_rolling[stat]['div']]==1]),
+                        color="#0C7BDC",linestyles='-.')
+            ax.hlines(sum(df_r[stat_plot_dict_rolling[stat]['y']].dropna())/sum(df_r[stat_plot_dict_rolling[stat]['div']].dropna()),
+                        xmin=window_width,
+                        xmax=len(df_r[df_r[stat_plot_dict_rolling[stat]['div']]==1]),
+                        color="#FFB000",linestyles='--')
+            #print(sum(df_r[stat_plot_dict_rolling[stat]['y']].dropna())/sum(df_r[stat_plot_dict_rolling[stat]['div']].dropna()))
+            ax.tick_params(axis='x', labelsize=8)  # Set x-axis ticks size
+            ax.tick_params(axis='y', labelsize=8)  # Set y-axis ticks size
+            ax.set_title(f"{window_width} {stat_plot_dict_rolling[stat]['x_label']} Rolling {stat_plot_dict_rolling[stat]['name']}",fontsize=8)
+            ax.set_ylim(stat_plot_dict_rolling[stat]['y_min'],stat_plot_dict_rolling[stat]['y_max'])
+            ax.grid(True,alpha=0.2)
+
+
+            if stat_plot_dict_rolling[stat]['form'] == '3f':
+                ax.yaxis.set_major_formatter(mtick.StrMethodFormatter('{x:.3f}'))
+
+            elif stat_plot_dict_rolling[stat]['form'] == '1f': 
+                ax.yaxis.set_major_formatter(mtick.StrMethodFormatter('{x:.1f}'))  
+
+            elif stat_plot_dict_rolling[stat]['form'] == '1%':  
+                ax.yaxis.set_major_formatter(mtick.PercentFormatter(1)) 
+
+            return plot
+
+        dict_level = {1:'MLB',
+        11:'MiLB AAA',
+        12:'MiLB AA',
+        13:'MiLB High-A',
+        14:'MiLB A'}
+
+        def plot_card(sport_id_input=sport_id_input,
+                    batter_select=batter_select,
+                    df_roll=df_roll,
+                    df_summ_player=df_summ_player,
+                    df_summ_update = df_summ_update,
+                    df_summ_batter_pitch_pct=df_summ_batter_pitch_pct,
+                    ):
+                        
+                #player_df = get_players(sport_id=sport_id_input)
+                mlb_teams = mlb_stats.get_teams()
+                team_logos = pd.read_csv('team_logos.csv')
+                if sport_id_input == 1:
+                        player_bio = requests.get(f'https://statsapi.mlb.com/api/v1/people?personIds={batter_select}&appContext=majorLeague&hydrate=currentTeam').json()
+                else:
+                        player_bio = requests.get(f'https://statsapi.mlb.com/api/v1/people?personIds={batter_select}&appContext=minorLeague&hydrate=currentTeam').json() 
+                
+                fig = plt.figure(figsize=(10, 10))#,dpi=600)
+                plt.rcParams.update({'figure.autolayout': True})
+                fig.set_facecolor('white')
+                sns.set_theme(style="whitegrid", palette="pastel")    
+                from matplotlib.gridspec import GridSpec
+                gs = GridSpec(5, 5, width_ratios=[0.2,1,1,1,0.2], height_ratios=[0.6,0.05,0.15,.30,0.025])
+                gs.update(hspace=0.4, wspace=0.5)
+                
+                # gs.update(left=0.1,right=0.9,top=0.97,bottom=0.03,wspace=0.3,hspace=0.09)
+
+                # ax1 = plt.subplot(4,1,1)
+                # ax2 = plt.subplot(2,2,2)
+                # ax3 = plt.subplot(2,2,3)
+                # ax4 = plt.subplot(4,1,4)
+                #ax2 = plt.subplot(3,3,2)
+
+                # Add subplots to the grid
+                ax = fig.add_subplot(gs[0, :]) 
+                #ax1 = fig.add_subplot(gs[2, 0]) 
+                # ax2 = fig.add_subplot(gs[2, :])  # Subplot at the top-right position
+                # fig, ax = plt.subplots(1,1,figsize=(10,12))
+                ax.axis('off')
+
+                width = 0.08
+                height = width*2.45
+                if df_summ_player['launch_speed'].isna().values[0]:
+                        df_summ_player['sweet_spot_percent'] = np.nan
+                        df_summ_player['barrel_percent'] = np.nan
+                        df_summ_player['hard_hit_percent'] = np.nan
+                        df_summ_player['xwoba_percent'] = np.nan
+                if df_summ_player['launch_speed'].isna().values[0]:
+                        df_summ_player_pct['sweet_spot_percent'] = np.nan
+                        df_summ_player_pct['barrel_percent'] = np.nan
+                        df_summ_player_pct['hard_hit_percent'] = np.nan    
+                        df_summ_player_pct['xwoba_percent'] = np.nan    
+                # x = 0.1
+                # y = 0.9
+                for cat in range(len(column_list)):
+
+                        # if cat < len(column_list)/2:
+                        x_adjust, y_adjust =(0.85/7*8)*cat/8+0.075 - (0.85/7*8)*math.floor((cat)/8), 0.45-math.floor((cat)/8)/3.2
+
+                        # else:
+                        #     x_adjust, y_adjust = (cat-len(column_list)/2)*(1.7/(math.ceil((len(column_list)-1))))+0.1, 0.5
+                        #print( x_adjust, y_adjust)
+                        if sum(df_summ_player[column_list[cat]].isna()) < 1:
+                                print(f'{df_summ_player[column_list[cat]].values[0]:{stat_plot_dict[column_list[cat]]["format"]}}')
+                                ax.text(s = f'{df_summ_player[column_list[cat]].values[0]:{stat_plot_dict[column_list[cat]]["format"]}}'.format().strip(),
+
+                                        x = x_adjust,
+                                        y = y_adjust,
+                                        color='black',
+                                        #bbox=dict(facecolor='none', edgecolor='black', pad=10.0),
+                                        fontsize = 16,
+                                        ha='center',
+                                        va='center')
+
+                                if stat_plot_dict[column_list[cat]]['flip']:
+
+                                        bbox = patches.Rectangle((x_adjust- width/2,y_adjust- height/2), width, height, linewidth=1,edgecolor='black',
+                                                                facecolor = get_color(df_summ_player_pct[column_list[cat]].values[0],0,1,cmap_name=cmap_sum_r))
+                                        ax.add_patch(bbox)
+
+
+                                else:
+                                        bbox = patches.Rectangle((x_adjust- width/2,y_adjust- height/2), width, height, linewidth=1,edgecolor='black',
+                                                                facecolor = get_color(df_summ_player_pct[column_list[cat]].values[0],0,1,cmap_name=cmap_sum))
+                                        ax.add_patch(bbox)
+                        else:
+                                print(f'{df_summ_player[column_list[cat]].values[0]:{stat_plot_dict[column_list[cat]]["format"]}}')
+                                ax.text(s = f'{df_summ_player[column_list[cat]].fillna("N/A").values[0]}',
+
+                                        x = x_adjust,
+                                        y = y_adjust,
+                                        color='black',
+                                        #bbox=dict(facecolor='none', edgecolor='black', pad=10.0),
+                                        fontsize = 14,
+                                        ha='center',
+                                        va='center')
+
+                                if stat_plot_dict[column_list[cat]]['flip']:
+
+                                        bbox = patches.Rectangle((x_adjust- width/2,y_adjust- height/2), width, height, linewidth=1,edgecolor='black',
+                                                                facecolor = get_color(df_summ_player_pct[column_list[cat]].values[0],0,1,cmap_name=cmap_sum_r))
+                                        ax.add_patch(bbox)
+
+
+                                else:
+                                        bbox = patches.Rectangle((x_adjust- width/2,y_adjust- height/2), width, height, linewidth=1,edgecolor='black',
+                                                                facecolor = get_color(df_summ_player_pct[column_list[cat]].values[0],0,1,cmap_name=cmap_sum))
+                                        ax.add_patch(bbox)                        
+
+                        ax.text(s = stat_plot_dict[column_list[cat]]['name'],
+
+                        x = x_adjust,
+                        y = y_adjust-0.14,
+                        color='black',
+                        #bbox=dict(facecolor='none', edgecolor='black', pad=10.0),
+                        fontsize = 12,
+                        ha='center',
+                        va='center')
+
+                ax.text(s = f"{player_bio['people'][0]['fullName']}",
+
+                        x = 0.5,
+                        y = 0.95,
+                        color='black',
+                        #bbox=dict(facecolor='none', edgecolor='black', pad=10.0),
+                        fontsize = 28,
+                        ha='center',
+                        va='center')
+                if 'parentOrgId' in player_bio['people'][0]['currentTeam']:
+                        
+                        ax.text(s = f"{player_bio['people'][0]['primaryPosition']['abbreviation']}, {mlb_teams[mlb_teams['team_id'] == player_bio['people'][0]['currentTeam']['parentOrgId']]['franchise'].values[0]}",
+
+                        x = 0.5,
+                        y = 0.85,
+                        color='black',
+                        #bbox=dict(facecolor='none', edgecolor='black', pad=10.0),
+                        fontsize = 14,
+                        ha='center',
+                        va='center')
+
+                else: ax.text(s = f"{player_bio['people'][0]['primaryPosition']['abbreviation']}, {player_bio['people'][0]['currentTeam']['name']}",
+
+                        x = 0.5,
+                        y = 0.85,
+                        color='black',
+                        #bbox=dict(facecolor='none', edgecolor='black', pad=10.0),
+                        fontsize = 14,
+                        ha='center',
+                        va='center')
+
+                ax.text(s =
+                        f"B/T: {player_bio['people'][0]['batSide']['code']}/"
+                        f"{player_bio['people'][0]['pitchHand']['code']}    "
+                        f"{player_bio['people'][0]['height']}/"
+                        f"{player_bio['people'][0]['weight']}",
+
+                        x = 0.5,
+                        y = 0.785,
+                        color='black',
+                        #bbox=dict(facecolor='none', edgecolor='black', pad=10.0),
+                        fontsize = 14,
+                        ha='center',
+                        va='center')
+
+                ax.text(s =
+
+                        f"DOB: {player_bio['people'][0]['birthDate']}    "
+                        f"Age: {player_bio['people'][0]['currentAge']}",
+                        x = 0.5,
+                        y = 0.72,
+                        color='black',
+                        #bbox=dict(facecolor='none', edgecolor='black', pad=10.0),
+                        fontsize = 14,
+                        ha='center',
+                        va='center')
+                if sport_id_input == 1:
+                    try: 
+                        url = f'https://img.mlbstatic.com/mlb-photos/image/upload/d_people:generic:headshot:67:current.png/w_213,q_auto:best/v1/people/{batter_select}/headshot/67/current.png'
+                        test_mage = plt.imread(url)
+                    except urllib.error.HTTPError as err:
+                        url = f'https://img.mlbstatic.com/mlb-photos/image/upload/d_people:generic:headshot:67:current.png/w_213,q_auto:best/v1/people/1/headshot/67/current.png'                
+
+                else:
+                    try: 
+                        url = f'https://img.mlbstatic.com/mlb-photos/image/upload/c_fill,g_auto/w_180/v1/people/{batter_select}/headshot/milb/current.png'
+                        test_mage = plt.imread(url)
+                    except urllib.error.HTTPError as err:
+                        url = f'https://img.mlbstatic.com/mlb-photos/image/upload/d_people:generic:headshot:67:current.png/w_213,q_auto:best/v1/people/1/headshot/67/current.png'
+                im = plt.imread(url)
+                # response = requests.get(url)
+                # im = Image.open(BytesIO(response.content), cmap='viridis')
+                # im = plt.imread(np.array(PIL.Image.open(urllib.request.urlopen(url))))
+
+                # ax = fig.add_axes([0,0,1,0.85], anchor='C', zorder=1)
+                imagebox = OffsetImage(im, zoom = 0.3)
+                ab = AnnotationBbox(imagebox, (0.125, 0.8), frameon = False)
+                ax.add_artist(ab)
+
+                if 'parentOrgId' in player_bio['people'][0]['currentTeam']:
+                        url = team_logos[team_logos['id'] == player_bio['people'][0]['currentTeam']['parentOrgId']]['imageLink'].values[0]
+
+                        im = plt.imread(url)
+                        # response = requests.get(url)
+                        # im = Image.open(BytesIO(response.content))
+                        # im = plt.imread(team_logos[team_logos['id'] == player_bio['people'][0]['currentTeam']['parentOrgId']]['imageLink'].values[0])
+                        # ax = fig.add_axes([0,0,1,0.85], anchor='C', zorder=1)
+                        imagebox = OffsetImage(im, zoom = 0.225)
+                        ab = AnnotationBbox(imagebox, (0.875, 0.8), frameon = False)
+                        ax.add_artist(ab)
+
+                else:
+                        url = team_logos[team_logos['id'] == player_bio['people'][0]['currentTeam']['id']]['imageLink'].values[0]
+                        im = plt.imread(team_logos[team_logos['id'] == player_bio['people'][0]['currentTeam']['id']]['imageLink'].values[0])
+
+                        # im = plt.imread(url)
+                        # response = requests.get(url)
+                        # im = Image.open(BytesIO(response.content))
+                        #im = plt.imread(team_logos[team_logos['id'] == player_bio['people'][0]['currentTeam']['parentOrgId']]['imageLink'].values[0])
+
+                        # ax = fig.add_axes([0,0,1,0.85], anchor='C', zorder=1)
+                        imagebox = OffsetImage(im, zoom = 0.225)
+                        ab = AnnotationBbox(imagebox, (0.875, 0.8), frameon = False)
+                        ax.add_artist(ab)
+
+                ax.text(s = f'2024 {dict_level[sport_id_input]} Metrics',
+
+                        x = 0.5,
+                        y = 0.62,
+                        color='black',
+                        #bbox=dict(facecolor='none', edgecolor='black', pad=10.0),
+                        fontsize = 20,
+                        ha='center',
+                        va='center')
+
+                df_plot = df_summ_batter_pitch[column_list_pitch].xs([batter_select,df_summ_update.xs(batter_select,level=0).index[0]]).sort_values('pitches',ascending=False)#.dropna()
+                df_plot = df_plot[df_plot['pitches'] > 0]
+
+                df_plot_pct = df_summ_batter_pitch_pct[column_list_pitch].xs([batter_select,df_summ_update.xs(batter_select,level=0).index[0]]).sort_values('pitches',ascending=False)#.dropna()
+
+                value = 1
+                # Normalize the value
+                colormap = plt.get_cmap(cmap_sum)
+                colormap_r = plt.get_cmap(cmap_sum_r)
+                norm = Normalize(vmin=0, vmax=1)
+
+
+
+                col_5_colour = [colormap_r(norm(x)) for x in list((df_summ_batter_pitch_pct_rank['chase_percent']))]
+                col_4_colour = [colormap_r(norm(x)) for x in list((df_summ_batter_pitch_pct_rank['whiff_rate']))]
+                col_3_colour = [colormap(norm(x)) for x in list((df_summ_batter_pitch_pct_rank['woba_percent_contact']))]
+                col_2_colour = ['white']*len(df_summ_batter_pitch_pct_rank)
+                col_1_colour = ['white']*len(df_summ_batter_pitch_pct_rank)
+                colour_df = pd.DataFrame(data=[col_1_colour,col_2_colour,col_3_colour,col_4_colour,col_5_colour]).T.values
+
+                ax_table = fig.add_subplot(gs[2, 1:-1]) 
+                ax_table.axis('off')
+                print(colour_df)
+                print(df_plot)
+                table = ax_table.table(cellText=df_plot.values, colLabels=[stat_plot_dict[x]['name'] for x in df_plot.columns],rowLabels=df_plot.index, cellLoc='center',
+                                        bbox=[0.13, 0.0, 0.79, 1],colWidths=[0.1]*len(df_plot.columns),
+                                        loc='center',cellColours=colour_df)
+                ax_table.text(x=0.5,y=1.1,s='Metrics By Pitch Type',ha='center',fontdict={ 'size': 12},fontname='arial')
+                
+                w, h = table[0,1].get_width(), table[0,1].get_height()
+                cell_i = table.add_cell(0, -1, w,h, text='Pitch Type')
+                cell_i.get_text().set_horizontalalignment('left')
+                min_font_size = 12
+                        # Set table properties
+                
+                table.auto_set_font_size(False)
+                table.set_fontsize(min_font_size)
+                #table.set_fontname('arial')
+                table.scale(1, len(df_plot)*0.3)
+
+
+                int_list = ['pitches','bip']
+                for fl in int_list:
+                        # Subset of column names
+                        subset_columns = [fl]
+                        
+                        # Get the list of column indices
+                        column_indices = [df_plot.columns.get_loc(col) for col in subset_columns]
+                        
+                        # # print(column_indices)
+                        for row_l in range(1,len(df_plot)+1):
+                        #     print(row_l)
+                                if table.get_celld()[(row_l,column_indices[0])].get_text().get_text() != '—':
+                        #     print()
+                        #     print(fl)
+                                        table.get_celld()[(row_l,column_indices[0])].get_text().set_text('{:,.0f}'.format(float(table.get_celld()[(row_l,column_indices[0])].get_text().get_text().strip('%'))))
+
+
+
+                float_3_list = ['xwoba_percent']
+                for fl in float_3_list:
+                        # Subset of column names
+                        subset_columns = [fl]
+                        
+                        # Get the list of column indices
+                        column_indices = [df_plot.columns.get_loc(col) for col in subset_columns]
+                        
+                        # # print(column_indices)
+                        for row_l in range(1,len(df_plot)+1):
+                        #     print(row_l)
+                                if table.get_celld()[(row_l,column_indices[0])].get_text().get_text() != '—':
+                        #     print()
+                        #     print(fl)
+                                        table.get_celld()[(row_l,column_indices[0])].get_text().set_text('{:,.3f}'.format(float(table.get_celld()[(row_l,column_indices[0])].get_text().get_text().strip('%'))))
+
+
+
+                percent_list = ['whiff_rate','chase_percent']
+
+                
+                for fl in percent_list:
+                        # Subset of column names
+                                subset_columns = [fl]
+                                
+                                # Get the list of column indices
+                                column_indices = [df_plot.columns.get_loc(col) for col in subset_columns]
+                                
+                                # # print(column_indices)
+                                for row_l in range(1,len(df_plot)+1):
+                                #     print(row_l)
+                                        if table.get_celld()[(row_l,column_indices[0])].get_text().get_text() != '—':
+                                        
+                                #     print(fl)
+                                                table.get_celld()[(row_l,column_indices[0])].get_text().set_text('{:,.1%}'.format(float(table.get_celld()[(row_l,column_indices[0])].get_text().get_text().strip('%'))))
+
+
+
+                stat_1 = input.stat_1()
+                window_width_1 = input.window_1()
+                stat_2 = input.stat_2()
+                window_width_2 = input.window_2()
+                stat_3 = input.stat_3()
+                window_width_3 = input.window_3()
+
+                
+                inset_ax = ax = fig.add_subplot(gs[3, 1]) 
+                rolling_plot(stat=stat_1,window_width=window_width_1,ax=inset_ax,df_r=df_roll,df_r_summ_avg=df_summ_avg_update)
+
+                inset_ax = ax = fig.add_subplot(gs[3, 2]) 
+                rolling_plot(stat=stat_2,window_width=window_width_2,ax=inset_ax,df_r=df_roll,df_r_summ_avg=df_summ_avg_update)
+
+                inset_ax = ax = fig.add_subplot(gs[3, 3]) 
+                rolling_plot(stat=stat_3,window_width=window_width_3,ax=inset_ax,df_r=df_roll,df_r_summ_avg=df_summ_avg_update)
+
+                ax_bot = ax = fig.add_subplot(gs[4, :]) 
+
+                ax_bot.text(x=0.05,y=-0.5,s='By: @TJStats',ha='left',fontdict={ 'size': 14},fontname='arial')
+                ax_bot.text(x=1-0.05,y=-0.5,s='Data: MLB',ha='right',fontdict={ 'size': 14},fontname='arial')
+                ax_bot.axis('off')
+
+                
+                ax_cbar = fig.add_subplot(gs[1,1:-1]) 
+                
+                cb = matplotlib.colorbar.ColorbarBase(ax_cbar, orientation='horizontal',
+                                        cmap=cmap_sum)
+                #ax_cbar.axis('off')
+                ax_cbar.text(x=0.5,y=1.2,s='Colour Scale - Percentiles',ha='center',fontdict={ 'size': 12},fontname='arial')
+                ax_cbar.text(s='0%',x=0.01,y=0.5,va='center',ha='left')
+                ax_cbar.text(s='100%',x=0.99,y=0.5,va='center',ha='right')
+                # ax_cbar.text(s='50%',x=0.5,y=0.5,va='center',ha='center')
+                # ax_cbar.text(s='50%',x=0.5,y=0.5,va='center',ha='center')
+                # ax_cbar.text(s='50%',x=0.5,y=0.5,va='center',ha='center')
+                ax_cbar.set_xticks([])
+                ax_cbar.set_yticks([])
+                ax_cbar.set_xticklabels([])
+                ax_cbar.set_yticklabels([])
+
+                # Display only the outline of the axis
+                for spine in ax_cbar.spines.values():
+                        spine.set_visible(True)  # Show only the outline
+                        spine.set_color('black')  # Set the color to black
+
+                # fig.set_facecolor('#ffffff')
+
+                return fig.subplots_adjust(left=0.03, right=0.97, top=0.95, bottom=0.05)
+
+
+        return  plot_card(sport_id_input=sport_id_input,
+                    batter_select=batter_select,
+                    df_roll=df_roll,
+                    df_summ_player=df_summ_player,
+                    df_summ_batter_pitch_pct=df_summ_batter_pitch_pct,
+                    )
+
+
+
+from shiny import App, Inputs, Outputs, Session, reactive, render, req, ui
+
+
+
+app = App(ui.page_fluid(
+#    ui.tags.base(href=base_url),
+    ui.tags.div(
+         {"style": "width:90%;margin: 0 auto;max-width: 1600px;"},
+        ui.tags.style(
+            """
+            h4 {
+                margin-top: 1em;font-size:35px;
+            }
+            h2{
+                font-size:25px;
+            }
+            """
+         ),
+    shinyswatch.theme.simplex(),
+    ui.tags.h4("TJStats"),
+    ui.tags.i("Baseball Analytics and Visualizations"),
+    ui.row(
+    ui.layout_sidebar(
+        
+        ui.panel_sidebar(ui.output_ui('test',"Select Batter"),
+                         ui.input_select('stat_1',"Select Rolling Stat 1",stat_roll_dict,selectize=True),
+                         ui.input_numeric('window_1',"Select Rolling Window 1",value=100),
+                         ui.input_select('stat_2',"Select Rolling Stat 2",stat_roll_dict,selected='k_percent',selectize=True),
+                         ui.input_numeric('window_2',"Select Rolling Stat 2",value=100),
+                         ui.input_select('stat_3',"Select Rolling Stat 3",stat_roll_dict,selected='bb_percent',selectize=True),
+                         ui.input_numeric('window_3',"Select Rolling Stat 3",value=100),
+                         ui.input_action_button("go", "Generate",class_="btn-primary"),width=2),
+
+   ui.page_navbar(     
+   
+            ui.nav_panel("Player Cards", 
+                ui.output_plot('a_plot',width='1000px',height='1000px')),  
+            id="my_tabs",       
+        ))),)),server)
+
+
+
+# app = App(app_ui, server)

batting_update.py

@@ -0,0 +1,608 @@
+import pandas as pd
+import numpy as np
+import joblib
+import math
+import pickle
+
+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')
+barrel_model = joblib.load('joblib_model/barrel_model.joblib')
+
+
+def percentile(n):
+    def percentile_(x):
+        return np.nanpercentile(x, n)
+    percentile_.__name__ = 'percentile_%s' % n
+    return percentile_
+
+
+def df_update(df=pd.DataFrame()):
+    df.loc[df['sz_top']==0,'sz_top'] = np.nan
+    df.loc[df['sz_bot']==0,'sz_bot'] = np.nan
+
+
+    df['in_zone'] = [x < 10 if x > 0 else np.nan for x in df['zone']]
+    if len(df.loc[(~df['x'].isnull())&(df['px'].isnull()),'px']) > 0:
+        df.loc[(~df['x'].isnull())&(df['px'].isnull()),'px'] = px_model.predict(df.loc[(~df['x'].isnull())&(df['px'].isnull())][['x']])
+        df.loc[(~df['y'].isnull())&(df['pz'].isnull()),'pz'] = px_model.predict(df.loc[(~df['y'].isnull())&(df['pz'].isnull())][['y']]) + 3.2
+
+    
+        # df['in_zone'] =  [x < 10 if x > 0 else np.nan for x in df['zone']]
+    if len(df.loc[(~df['px'].isna())&
+                  (df['in_zone'].isna())&
+                  (~df['sz_top'].isna())]) > 0:
+            print('We found missing data')
+            df.loc[(~df['px'].isna())&
+                            (df['in_zone'].isna())&
+                            (~df['sz_top'].isna()),'in_zone'] = in_zone_model.predict(df.loc[(~df['px'].isna())&
+                                                                                                                    (df['in_zone'].isna())&
+                                                                                                                        (~df['sz_top'].isna())][['px','pz','sz_top','sz_bot']].values)
+
+    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']
+
+
+
+    conditions_hit = [df.event_type.isin(hit_codes)]
+    choices_hit = [True]
+    df['hits'] = np.select(conditions_hit, choices_hit, default=False)
+
+    conditions_ab = [df.event_type.isin(ab_codes)]
+    choices_ab = [True]
+    df['ab'] = np.select(conditions_ab, choices_ab, default=False)
+
+    conditions_obp_true = [df.event_type.isin(obp_true_codes)]
+    choices_obp_true = [True]
+    df['on_base'] = np.select(conditions_obp_true, choices_obp_true, default=False)
+
+    conditions_obp = [df.event_type.isin(obp_codes)]
+    choices_obp = [True]
+    df['obp'] = np.select(conditions_obp, choices_obp, default=False)
+
+    bip_codes = ['In play, no out', 'In play, run(s)','In play, out(s)']
+    
+    conditions_bip = [df.play_description.isin(bip_codes)]
+    choices_bip = [True]
+    df['bip'] = np.select(conditions_bip, choices_bip, default=False)
+
+    # conditions = [
+    #     (df['launch_speed'].isna()),
+    #     (df['launch_speed']*1.5 - df['launch_angle'] >= 117 ) & (df['launch_speed'] + df['launch_angle'] >= 124) & (df['launch_speed'] > 98) & (df['launch_angle'] >= 8) & (df['launch_angle'] <= 50)
+    # ]
+    df['bip_div'] = ~df.launch_speed.isna()
+    # choices = [False,True]
+    # df['barrel'] = np.select(conditions, choices, default=np.nan)
+    # df['barrel'] = loaded_model.predict(df[['launch_speed','launch_angle']].fillna(0).values)
+    df['barrel'] = np.nan
+    if len(df.loc[(~df['launch_speed'].isnull())]) > 0:
+        df.loc[(~df['launch_speed'].isnull())&(~df['launch_angle'].isnull()),'barrel'] = barrel_model.predict(df.loc[(~df['launch_speed'].isnull())&(~df['launch_angle'].isnull())][['launch_speed','launch_angle']])
+
+
+    conditions_ss = [
+        (df['launch_angle'].isna()),
+        (df['launch_angle'] >= 8 ) * (df['launch_angle'] <= 32 )
+    ]
+
+    choices_ss = [False,True]
+    df['sweet_spot'] = np.select(conditions_ss, choices_ss, default=np.nan)
+
+    conditions_hh = [
+        (df['launch_speed'].isna()),
+        (df['launch_speed'] >= 94.5 )
+    ]
+
+    choices_hh = [False,True]
+    df['hard_hit'] = np.select(conditions_hh, choices_hh, default=np.nan)
+
+
+    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]
+
+    df['tb'] = np.select(conditions_tb, choices_tb, default=np.nan)
+
+    conditions_woba = [
+        (df['event_type'].isin(['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.696,
+                    0.726,
+                    0.883,
+                    1.244,
+                    1.569,
+                    2.004]
+
+    df['woba'] = np.select(conditions_woba, choices_woba, default=np.nan)
+
+
+    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']
+
+
+    
+    
+    
+
+    conditions_woba_code = [
+        (df['event_type'].isin(woba_codes))
+    ]
+
+    choices_woba_code = [1]
+
+    df['woba_codes'] = np.select(conditions_woba_code, choices_woba_code, default=np.nan)
+
+
+    df['woba_contact'] = [df['woba'].values[x] if df['bip'].values[x] == 1 else np.nan for x in range(len(df['woba_codes']))]
+
+    #df['in_zone'] =  [x < 10 if type(x) == int else np.nan for x in df['zone']]
+
+    # df['in_zone_2'] = in_zone_model.predict(df[['x','y','sz_bot','sz_top']].fillna(0).values)
+    # df['in_zone_3'] = df['in_zone_2'] < 10
+    # df.loc[df['in_zone'].isna(),'in_zone'] = df.loc[df['in_zone'].isna(),'in_zone_3'].fillna(0)
+
+
+    df['whiffs'] = [1 if ((x == 'S')|(x == 'W')|(x =='T')) else 0 for x in df.play_code]
+    df['csw'] = [1 if ((x == 'S')|(x == 'W')|(x =='T')|(x == 'C')) else 0 for x in df.play_code]
+    df['swings'] = [1 if x == True else 0 for x in df.is_swing]
+
+
+    df['out_zone'] = df.in_zone == False
+    df['zone_swing'] = (df.in_zone == True)&(df.swings == 1)
+    df['zone_contact'] = (df.in_zone == True)&(df.swings == 1)&(df.whiffs == 0)
+    df['ozone_swing'] = (df.in_zone==False)&(df.swings == 1)
+    df['ozone_contact'] = (df.in_zone==False)&(df.swings == 1)&(df.whiffs == 0)
+
+    df['k'] = df.event_type.isin(list(filter(None, [x if 'strikeout' in x else '' for x in df.event_type.dropna().unique()])))
+    df['bb'] = df.event_type.isin(['walk','intent_walk'])
+
+    df['k_minus_bb'] = df['k'].astype(np.float32)-df['bb'].astype(np.float32)
+    df['bb_minus_k'] = df['bb'].astype(np.float32)-df['k'].astype(np.float32)
+
+    df['pa']  = [1 if isinstance(x, str) else 0 for x in df.event_type]
+    df['pitches']  = [1 if x else 0 for x in df.is_pitch]
+
+
+    df.loc[df['launch_speed'].isna(),'barrel'] = np.nan
+
+
+    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':np.nan,
+    'IN':np.nan,
+    'PO':np.nan,
+    'AB':np.nan,
+    'AS':np.nan,
+    'NP':np.nan}
+    df['pitch_category'] = df['pitch_type'].map(pitch_cat).fillna('Unknown')
+    df['average'] = 'average'
+
+    df.loc[df['trajectory'] == 'bunt_popup','trajectory'] = 'popup'
+    df.loc[df['trajectory'] == 'bunt_grounder','trajectory'] = 'ground_ball'
+    df.loc[df['trajectory'] == '','trajectory'] = np.nan
+    df.loc[df['trajectory'] == 'bunt_line_drive','trajectory'] = 'line_drive'
+    df[['trajectory_fly_ball','trajectory_ground_ball','trajectory_line_drive','trajectory_popup']] = pd.get_dummies(df['trajectory'], prefix='trajectory')
+
+    df['attack_zone'] = np.nan
+
+
+
+    df.loc[df[['px','pz','sz_top','sz_bot']].isnull().sum(axis=1)==0,'attack_zone'] = attack_zone_model.predict(df.loc[df[['px','pz','sz_top','sz_bot']].isnull().sum(axis=1)==0][['px','pz','sz_top','sz_bot']])
+
+
+
+    df['heart'] = df['attack_zone'] == 0
+    df['shadow'] = df['attack_zone'] == 1
+    df['chase'] = df['attack_zone'] == 2
+    df['waste'] = df['attack_zone'] == 3
+
+    df['heart_swing'] = (df['attack_zone'] == 0)&(df['swings']==1)
+    df['shadow_swing'] = (df['attack_zone'] == 1)&(df['swings']==1)
+    df['chase_swing'] = (df['attack_zone'] == 2)&(df['swings']==1)
+    df['waste_swing'] = (df['attack_zone'] == 3)&(df['swings']==1)
+    
+    df['xwoba'] = np.nan
+    df['xwoba_contact'] = np.nan
+
+    if len(df.loc[df[['launch_angle','launch_speed']].isnull().sum(axis=1)==0,'xwoba']) > 0:
+        
+
+        df.loc[df[['launch_angle','launch_speed']].isnull().sum(axis=1)==0,'xwoba']  = [sum(x) for x in xwoba_model.predict_proba(df.loc[df[['launch_angle','launch_speed']].isnull().sum(axis=1)==0][['launch_angle','launch_speed']]) * ([0, 0.883,1.244,1.569,2.004])]
+
+        ## Assign a value of 0.696 to every walk in the dataset
+        df.loc[df['event_type'].isin(['walk']),'xwoba'] = 0.696
+
+        ## Assign a value of 0.726 to every hit by pitch in the dataset
+        df.loc[df['event_type'].isin(['hit_by_pitch']),'xwoba'] = 0.726
+
+        ## Assign a value of 0 to every Strikeout in the dataset 
+        df.loc[df['event_type'].isin(['strikeout','strikeout_double_play']),'xwoba'] = 0
+
+        
+        df.loc[df[['launch_angle','launch_speed']].isnull().sum(axis=1)==0,'xwoba_contact']  = [sum(x) for x in xwoba_model.predict_proba(df.loc[df[['launch_angle','launch_speed']].isnull().sum(axis=1)==0][['launch_angle','launch_speed']]) * ([0, 0.883,1.244,1.569,2.004])]
+    
+
+    return df
+
+def df_update_summ(df=pd.DataFrame()):
+    df_summ = df.groupby(['batter_id','batter_name']).agg(
+        pa = ('pa','sum'),
+        ab = ('ab','sum'),
+        obp_pa = ('obp','sum'),
+        hits = ('hits','sum'),
+        on_base = ('on_base','sum'),
+        k = ('k','sum'),
+        bb = ('bb','sum'),
+        bb_minus_k = ('bb_minus_k','sum'),
+        csw = ('csw','sum'),
+        bip = ('bip','sum'),
+        bip_div = ('bip_div','sum'),
+        tb = ('tb','sum'),
+        woba = ('woba','sum'),
+        woba_contact = ('woba_contact','sum'),
+        xwoba = ('xwoba','sum'),
+        xwoba_contact = ('xwoba_contact','sum'),       
+        woba_codes = ('woba_codes','sum'),
+        hard_hit = ('hard_hit','sum'),
+        barrel = ('barrel','sum'),
+        sweet_spot = ('sweet_spot','sum'),
+        max_launch_speed = ('launch_speed','max'),
+        launch_speed_90 =  ('launch_speed',percentile(90)),
+        launch_speed = ('launch_speed','mean'),
+        launch_angle = ('launch_angle','mean'),
+        pitches = ('is_pitch','sum'),
+        swings =  ('swings','sum'),
+        in_zone = ('in_zone','sum'),
+        out_zone = ('out_zone','sum'),
+        whiffs = ('whiffs','sum'),
+        zone_swing = ('zone_swing','sum'),
+        zone_contact = ('zone_contact','sum'),
+        ozone_swing = ('ozone_swing','sum'),
+        ozone_contact = ('ozone_contact','sum'),
+        ground_ball = ('trajectory_ground_ball','sum'),
+        line_drive = ('trajectory_line_drive','sum'),
+        fly_ball =('trajectory_fly_ball','sum'),
+        pop_up = ('trajectory_popup','sum'),
+        attack_zone = ('attack_zone','count'),
+        heart = ('heart','sum'),
+        shadow = ('shadow','sum'),
+        chase = ('chase','sum'),
+        waste = ('waste','sum'),
+        heart_swing = ('heart_swing','sum'),
+        shadow_swing = ('shadow_swing','sum'),
+        chase_swing = ('chase_swing','sum'),
+        waste_swing = ('waste_swing','sum'),
+        ).reset_index()
+    return df_summ
+
+def df_update_summ_avg(df=pd.DataFrame()):
+    df_summ_avg = df.groupby(['average']).agg(
+        pa = ('pa','sum'),
+        ab = ('ab','sum'),
+        obp_pa = ('obp','sum'),
+        hits = ('hits','sum'),
+        on_base = ('on_base','sum'),
+        k = ('k','sum'),
+        bb = ('bb','sum'),
+        bb_minus_k = ('bb_minus_k','sum'),
+        csw = ('csw','sum'),
+        bip = ('bip','sum'),
+        bip_div = ('bip_div','sum'),
+        tb = ('tb','sum'),
+        woba = ('woba','sum'),
+        woba_contact = ('woba_contact','sum'),
+        xwoba = ('xwoba','sum'),
+        xwoba_contact = ('xwoba_contact','sum'),       
+        woba_codes = ('woba_codes','sum'),
+        hard_hit = ('hard_hit','sum'),
+        barrel = ('barrel','sum'),
+        sweet_spot = ('sweet_spot','sum'),
+        max_launch_speed = ('launch_speed','max'),
+        launch_speed_90 =  ('launch_speed',percentile(90)),
+        launch_speed = ('launch_speed','mean'),
+        launch_angle = ('launch_angle','mean'),
+        pitches = ('is_pitch','sum'),
+        swings =  ('swings','sum'),
+        in_zone = ('in_zone','sum'),
+        out_zone = ('out_zone','sum'),
+        whiffs = ('whiffs','sum'),
+        zone_swing = ('zone_swing','sum'),
+        zone_contact = ('zone_contact','sum'),
+        ozone_swing = ('ozone_swing','sum'),
+        ozone_contact = ('ozone_contact','sum'),
+        ground_ball = ('trajectory_ground_ball','sum'),
+        line_drive = ('trajectory_line_drive','sum'),
+        fly_ball =('trajectory_fly_ball','sum'),
+        pop_up = ('trajectory_popup','sum'),
+        attack_zone = ('attack_zone','count'),
+        heart = ('heart','sum'),
+        shadow = ('shadow','sum'),
+        chase = ('chase','sum'),
+        waste = ('waste','sum'),
+        heart_swing = ('heart_swing','sum'),
+        shadow_swing = ('shadow_swing','sum'),
+        chase_swing = ('chase_swing','sum'),
+        waste_swing = ('waste_swing','sum'),       
+
+
+
+
+        ).reset_index()
+    return df_summ_avg
+
+def df_summ_changes(df_summ=pd.DataFrame()):
+    df_summ['avg'] = [df_summ.hits[x]/df_summ.ab[x] if df_summ.ab[x] != 0 else np.nan for x in range(len(df_summ))]
+    df_summ['obp'] = [df_summ.on_base[x]/df_summ.obp_pa[x] if df_summ.obp_pa[x] != 0 else np.nan for x in range(len(df_summ))]
+    df_summ['slg'] =  [df_summ.tb[x]/df_summ.ab[x] if df_summ.ab[x] != 0 else np.nan for x in range(len(df_summ))]
+
+    df_summ['ops'] = df_summ['obp']+df_summ['slg']
+
+    df_summ['k_percent'] = [df_summ.k[x]/df_summ.pa[x] if df_summ.pa[x] != 0 else np.nan for x in range(len(df_summ))]
+    df_summ['bb_percent'] =[df_summ.bb[x]/df_summ.pa[x] if df_summ.pa[x] != 0 else np.nan for x in range(len(df_summ))]
+    df_summ['bb_minus_k_percent'] =[(df_summ.bb_minus_k[x])/df_summ.pa[x] if df_summ.pa[x] != 0 else np.nan for x in range(len(df_summ))]
+
+    df_summ['bb_over_k_percent'] =[df_summ.bb[x]/df_summ.k[x] if df_summ.k[x] != 0 else np.nan for x in range(len(df_summ))]
+
+
+
+
+    df_summ['csw_percent'] =[df_summ.csw[x]/df_summ.pitches[x] if df_summ.pitches[x] != 0 else np.nan for x in range(len(df_summ))]
+
+
+    df_summ['sweet_spot_percent'] = [df_summ.sweet_spot[x]/df_summ.bip_div[x] if df_summ.bip_div[x] != 0 else np.nan for x in range(len(df_summ))]
+
+    df_summ['woba_percent'] = [df_summ.woba[x]/df_summ.woba_codes[x] if df_summ.woba_codes[x] != 0 else np.nan for x in range(len(df_summ))]
+    df_summ['woba_percent_contact'] = [df_summ.woba_contact[x]/df_summ.bip[x] if df_summ.bip[x] != 0 else np.nan for x in range(len(df_summ))]
+    #df_summ['hard_hit_percent'] = [df_summ.sweet_spot[x]/df_summ.bip[x] if df_summ.bip[x] != 0 else np.nan for x in range(len(df_summ))]
+    df_summ['hard_hit_percent'] = [df_summ.hard_hit[x]/df_summ.bip_div[x] if df_summ.bip_div[x] != 0 else np.nan for x in range(len(df_summ))]
+
+
+    df_summ['barrel_percent'] = [df_summ.barrel[x]/df_summ.bip_div[x] if df_summ.bip_div[x] != 0 else np.nan for x in range(len(df_summ))]
+
+    df_summ['zone_contact_percent'] = [df_summ.zone_contact[x]/df_summ.zone_swing[x] if df_summ.zone_swing[x] != 0 else np.nan for x in range(len(df_summ))]
+
+    df_summ['zone_swing_percent'] = [df_summ.zone_swing[x]/df_summ.in_zone[x] if df_summ.in_zone[x] != 0 else np.nan for x in range(len(df_summ))]
+
+    df_summ['zone_percent'] = [df_summ.in_zone[x]/df_summ.pitches[x] if df_summ.pitches[x] > 0 else np.nan for x in range(len(df_summ))]
+
+    df_summ['chase_percent'] = [df_summ.ozone_swing[x]/(df_summ.pitches[x] - df_summ.in_zone[x]) if (df_summ.pitches[x]- df_summ.in_zone[x]) != 0 else np.nan for x in range(len(df_summ))]
+
+    df_summ['chase_contact'] = [df_summ.ozone_contact[x]/df_summ.ozone_swing[x] if df_summ.ozone_swing[x] != 0 else np.nan for x in range(len(df_summ))]
+
+    df_summ['swing_percent'] = [df_summ.swings[x]/df_summ.pitches[x] if df_summ.pitches[x] > 0 else np.nan for x in range(len(df_summ))]
+
+    df_summ['whiff_rate'] = [df_summ.whiffs[x]/df_summ.swings[x] if df_summ.swings[x] != 0 else np.nan for x in range(len(df_summ))]
+
+    df_summ['swstr_rate'] = [df_summ.whiffs[x]/df_summ.pitches[x] if df_summ.pitches[x] > 0 else np.nan for x in range(len(df_summ))]
+
+    df_summ['ground_ball_percent'] = [df_summ.ground_ball[x]/df_summ.bip[x] if df_summ.bip[x] != 0 else np.nan for x in range(len(df_summ))]
+
+    df_summ['line_drive_percent'] = [df_summ.line_drive[x]/df_summ.bip[x] if df_summ.bip[x] != 0 else np.nan for x in range(len(df_summ))]    
+
+    df_summ['fly_ball_percent'] = [df_summ.fly_ball[x]/df_summ.bip[x] if df_summ.bip[x] != 0 else np.nan for x in range(len(df_summ))]    
+
+    df_summ['pop_up_percent'] = [df_summ.pop_up[x]/df_summ.bip[x] if df_summ.bip[x] != 0 else np.nan for x in range(len(df_summ))]  
+
+
+    
+    df_summ['heart_zone_percent'] = [df_summ.heart[x]/df_summ.attack_zone[x] if df_summ.attack_zone[x] != 0 else np.nan for x in range(len(df_summ))]
+
+    df_summ['shadow_zone_percent'] = [df_summ.shadow[x]/df_summ.attack_zone[x] if df_summ.attack_zone[x] != 0 else np.nan for x in range(len(df_summ))]    
+
+    df_summ['chase_zone_percent'] = [df_summ.chase[x]/df_summ.attack_zone[x] if df_summ.attack_zone[x] != 0 else np.nan for x in range(len(df_summ))]    
+
+    df_summ['waste_zone_percent'] = [df_summ.waste[x]/df_summ.attack_zone[x] if df_summ.attack_zone[x] != 0 else np.nan for x in range(len(df_summ))]    
+    
+    
+    df_summ['heart_zone_swing_percent'] = [df_summ.heart_swing[x]/df_summ.heart[x] if df_summ.heart[x] != 0 else np.nan for x in range(len(df_summ))]
+
+    df_summ['shadow_zone_swing_percent'] = [df_summ.shadow_swing[x]/df_summ.shadow[x] if df_summ.shadow[x] != 0 else np.nan for x in range(len(df_summ))]    
+
+    df_summ['chase_zone_swing_percent'] = [df_summ.chase_swing[x]/df_summ.chase[x] if df_summ.chase[x] != 0 else np.nan for x in range(len(df_summ))]    
+
+    df_summ['waste_zone_swing_percent'] = [df_summ.waste_swing[x]/df_summ.waste[x] if df_summ.waste[x] != 0 else np.nan for x in range(len(df_summ))]    
+    
+
+
+
+    df_summ['xwoba_percent'] = [df_summ.xwoba[x]/df_summ.woba_codes[x] if df_summ.woba_codes[x] != 0 else np.nan for x in range(len(df_summ))]
+    df_summ['xwoba_percent_contact'] = [df_summ.xwoba_contact[x]/df_summ.bip[x] if df_summ.bip[x] != 0 else np.nan for x in range(len(df_summ))]
+
+    df_summ = df_summ.dropna(subset=['bip'])
+    return df_summ
+
+def df_summ_filter_out(df_summ=pd.DataFrame(),batter_select = 0):
+    df_summ_filter = df_summ[df_summ['pa'] >= min(math.floor(df_summ.xs(batter_select,level=0)['pa']/10)*10,500)]
+    df_summ_filter_pct = df_summ_filter.rank(pct=True,ascending=True)
+    df_summ_player = df_summ.xs(batter_select,level=0)
+    df_summ_player_pct = df_summ_filter_pct.xs(batter_select,level=0)
+    return df_summ_filter,df_summ_filter_pct,df_summ_player,df_summ_player_pct
+
+def df_summ_batter_pitch_up(df=pd.DataFrame()):
+    df_summ_batter_pitch = df.dropna(subset=['pitch_category']).groupby(['batter_id','batter_name','pitch_category']).agg(
+        pa = ('pa','sum'),
+        ab = ('ab','sum'),
+        obp_pa = ('obp','sum'),
+        hits = ('hits','sum'),
+        on_base = ('on_base','sum'),
+        k = ('k','sum'),
+        bb = ('bb','sum'),
+        bb_minus_k = ('bb_minus_k','sum'),
+        csw = ('csw','sum'),
+        bip = ('bip','sum'),
+        bip_div = ('bip_div','sum'),
+        tb = ('tb','sum'),
+        woba = ('woba','sum'),
+        woba_contact = ('xwoba_contact','sum'),
+        xwoba = ('xwoba','sum'),
+        xwoba_contact = ('xwoba','sum'),       
+        woba_codes = ('woba_codes','sum'),
+        hard_hit = ('hard_hit','sum'),
+        barrel = ('barrel','sum'),
+        sweet_spot = ('sweet_spot','sum'),
+        max_launch_speed = ('launch_speed','max'),
+        launch_speed_90 =  ('launch_speed',percentile(90)),
+        launch_speed = ('launch_speed','mean'),
+        launch_angle = ('launch_angle','mean'),
+        pitches = ('is_pitch','sum'),
+        swings =  ('swings','sum'),
+        in_zone = ('in_zone','sum'),
+        out_zone = ('out_zone','sum'),
+        whiffs = ('whiffs','sum'),
+        zone_swing = ('zone_swing','sum'),
+        zone_contact = ('zone_contact','sum'),
+        ozone_swing = ('ozone_swing','sum'),
+        ozone_contact = ('ozone_contact','sum'),
+        ground_ball = ('trajectory_ground_ball','sum'),
+        line_drive = ('trajectory_line_drive','sum'),
+        fly_ball =('trajectory_fly_ball','sum'),
+        pop_up = ('trajectory_popup','sum'),
+        attack_zone = ('attack_zone','count'),
+        heart = ('heart','sum'),
+        shadow = ('shadow','sum'),
+        chase = ('chase','sum'),
+        waste = ('waste','sum'),
+        heart_swing = ('heart_swing','sum'),
+        shadow_swing = ('shadow_swing','sum'),
+        chase_swing = ('chase_swing','sum'),
+        waste_swing = ('waste_swing','sum'),
+        ).reset_index()
+
+    #return df_summ_batter_pitch
+    df_summ_batter_pitch['avg'] = [df_summ_batter_pitch.hits[x]/df_summ_batter_pitch.ab[x] if df_summ_batter_pitch.ab[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+    df_summ_batter_pitch['obp'] = [df_summ_batter_pitch.on_base[x]/df_summ_batter_pitch.obp_pa[x] if df_summ_batter_pitch.obp_pa[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+    df_summ_batter_pitch['slg'] =  [df_summ_batter_pitch.tb[x]/df_summ_batter_pitch.ab[x] if df_summ_batter_pitch.ab[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+    df_summ_batter_pitch['ops'] = df_summ_batter_pitch['obp']+df_summ_batter_pitch['slg']
+
+    df_summ_batter_pitch['k_percent'] = [df_summ_batter_pitch.k[x]/df_summ_batter_pitch.pa[x] if df_summ_batter_pitch.pa[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+    df_summ_batter_pitch['bb_percent'] =[df_summ_batter_pitch.bb[x]/df_summ_batter_pitch.pa[x] if df_summ_batter_pitch.pa[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+    df_summ_batter_pitch['bb_minus_k_percent'] =[(df_summ_batter_pitch.bb_minus_k[x])/df_summ_batter_pitch.pa[x] if df_summ_batter_pitch.pa[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+    df_summ_batter_pitch['bb_over_k_percent'] =[df_summ_batter_pitch.bb[x]/df_summ_batter_pitch.k[x] if df_summ_batter_pitch.k[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+
+
+
+    df_summ_batter_pitch['csw_percent'] =[df_summ_batter_pitch.csw[x]/df_summ_batter_pitch.pitches[x] if df_summ_batter_pitch.pitches[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+
+    df_summ_batter_pitch['sweet_spot_percent'] = [df_summ_batter_pitch.sweet_spot[x]/df_summ_batter_pitch.bip_div[x] if df_summ_batter_pitch.bip_div[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+    df_summ_batter_pitch['woba_percent'] = [df_summ_batter_pitch.woba[x]/df_summ_batter_pitch.woba_codes[x] if df_summ_batter_pitch.woba_codes[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+    df_summ_batter_pitch['woba_percent_contact'] = [df_summ_batter_pitch.woba_contact[x]/df_summ_batter_pitch.bip[x] if df_summ_batter_pitch.bip[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+    #df_summ_batter_pitch['hard_hit_percent'] = [df_summ_batter_pitch.sweet_spot[x]/df_summ_batter_pitch.bip[x] if df_summ_batter_pitch.bip[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+    df_summ_batter_pitch['hard_hit_percent'] = [df_summ_batter_pitch.hard_hit[x]/df_summ_batter_pitch.bip_div[x] if df_summ_batter_pitch.bip_div[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+
+    df_summ_batter_pitch['barrel_percent'] = [df_summ_batter_pitch.barrel[x]/df_summ_batter_pitch.bip_div[x] if df_summ_batter_pitch.bip_div[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+    df_summ_batter_pitch['zone_contact_percent'] = [df_summ_batter_pitch.zone_contact[x]/df_summ_batter_pitch.zone_swing[x] if df_summ_batter_pitch.zone_swing[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+    df_summ_batter_pitch['zone_swing_percent'] = [df_summ_batter_pitch.zone_swing[x]/df_summ_batter_pitch.in_zone[x] if df_summ_batter_pitch.in_zone[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+    df_summ_batter_pitch['zone_percent'] = [df_summ_batter_pitch.in_zone[x]/df_summ_batter_pitch.pitches[x] if df_summ_batter_pitch.pitches[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+    df_summ_batter_pitch['chase_percent'] = [df_summ_batter_pitch.ozone_swing[x]/(df_summ_batter_pitch.pitches[x] - df_summ_batter_pitch.in_zone[x]) if (df_summ_batter_pitch.pitches[x]- df_summ_batter_pitch.in_zone[x]) != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+    df_summ_batter_pitch['chase_contact'] = [df_summ_batter_pitch.ozone_contact[x]/df_summ_batter_pitch.ozone_swing[x] if df_summ_batter_pitch.ozone_swing[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+    df_summ_batter_pitch['swing_percent'] = [df_summ_batter_pitch.swings[x]/df_summ_batter_pitch.pitches[x] if df_summ_batter_pitch.pitches[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+    df_summ_batter_pitch['whiff_rate'] = [df_summ_batter_pitch.whiffs[x]/df_summ_batter_pitch.swings[x] if df_summ_batter_pitch.swings[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+    df_summ_batter_pitch['swstr_rate'] = [df_summ_batter_pitch.whiffs[x]/df_summ_batter_pitch.pitches[x] if df_summ_batter_pitch.pitches[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+    df_summ_batter_pitch['heart_zone_percent'] = [df_summ_batter_pitch.heart[x]/df_summ_batter_pitch.attack_zone[x] if df_summ_batter_pitch.attack_zone[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+    df_summ_batter_pitch['shadow_zone_percent'] = [df_summ_batter_pitch.shadow[x]/df_summ_batter_pitch.attack_zone[x] if df_summ_batter_pitch.attack_zone[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]    
+
+    df_summ_batter_pitch['chase_zone_percent'] = [df_summ_batter_pitch.chase[x]/df_summ_batter_pitch.attack_zone[x] if df_summ_batter_pitch.attack_zone[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]    
+
+    df_summ_batter_pitch['waste_zone_percent'] = [df_summ_batter_pitch.waste[x]/df_summ_batter_pitch.attack_zone[x] if df_summ_batter_pitch.attack_zone[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]    
+    
+    
+    df_summ_batter_pitch['heart_zone_swing_percent'] = [df_summ_batter_pitch.heart_swing[x]/df_summ_batter_pitch.heart[x] if df_summ_batter_pitch.heart[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+    df_summ_batter_pitch['shadow_zone_swing_percent'] = [df_summ_batter_pitch.shadow_swing[x]/df_summ_batter_pitch.shadow[x] if df_summ_batter_pitch.shadow[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]    
+
+    df_summ_batter_pitch['chase_zone_swing_percent'] = [df_summ_batter_pitch.chase_swing[x]/df_summ_batter_pitch.chase[x] if df_summ_batter_pitch.chase[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]    
+
+    df_summ_batter_pitch['waste_zone_swing_percent'] = [df_summ_batter_pitch.waste_swing[x]/df_summ_batter_pitch.waste[x] if df_summ_batter_pitch.waste[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]    
+    
+
+
+
+    df_summ_batter_pitch['xwoba_percent'] = [df_summ_batter_pitch.xwoba[x]/df_summ_batter_pitch.woba_codes[x] if df_summ_batter_pitch.woba_codes[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+    df_summ_batter_pitch['xwoba_percent_contact'] = [df_summ_batter_pitch.xwoba_contact[x]/df_summ_batter_pitch.bip[x] if df_summ_batter_pitch.bip[x] != 0 else np.nan for x in range(len(df_summ_batter_pitch))]
+
+
+
+
+    df_summ_batter_pitch['bip'] = df_summ_batter_pitch['bip'].fillna(0)
+
+    return df_summ_batter_pitch