Upload 28 files

.dockerignore

@@ -0,0 +1,27 @@
+**/__pycache__
+**/.venv
+**/.classpath
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/bin
+**/charts
+**/docker-compose*
+**/compose*
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md

Dockerfile

@@ -1,20 +1,16 @@
 FROM python:3.9
 
-WORKDIR /code
+# Install dependencies
+COPY requirements.txt /app/
+RUN pip install -r /app/requirements.txt
 
-COPY ./requirements.txt /code/requirements.txt
+# Copy app files
+COPY app_name /app/app_name/
+COPY static/ /app/static/
+COPY templates/ /app/templates/
 
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+# Set working directory
+WORKDIR /app/app_name
 
-# Switch to the "user" user
-RUN useradd -m -u 1000 user
-USER user
-ENV HOME=/home/user \
-	PATH=/home/user/.local/bin:$PATH
-
-
-COPY . .
-
-EXPOSE 7860
-
-CMD ["shiny", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]
+# Set the command to run the app
+CMD ["python", "app.py"]

angle_ev_list_df.csv

@@ -0,0 +1,44 @@
+,launch_angle,launch_speed
+0,8,116.09999999999894
+1,9,115.099999999999
+2,10,114.09999999999906
+3,11,113.09999999999911
+4,12,112.09999999999917
+5,13,111.09999999999923
+6,14,110.09999999999928
+7,15,109.09999999999934
+8,16,108.0999999999994
+9,17,107.09999999999945
+10,18,106.09999999999951
+11,19,105.09999999999957
+12,20,104.09999999999962
+13,21,103.09999999999968
+14,22,102.09999999999974
+15,23,101.0999999999998
+16,24,100.09999999999985
+17,25,99.09999999999991
+18,26,98.09999999999997
+19,27,97.5
+20,28,97.5
+21,29,97.5
+22,30,98.09999999999997
+23,31,98.69999999999993
+24,32,99.39999999999989
+25,33,100.09999999999985
+26,34,100.69999999999982
+27,35,101.39999999999978
+28,36,102.09999999999974
+29,37,102.6999999999997
+30,38,103.39999999999966
+31,39,104.09999999999962
+32,40,104.69999999999959
+33,41,105.39999999999955
+34,42,106.09999999999951
+35,43,106.69999999999948
+36,44,107.39999999999944
+37,45,108.0999999999994
+38,46,108.69999999999936
+39,47,109.39999999999932
+40,48,110.09999999999928
+41,49,110.69999999999925
+42,50,111.39999999999921

app.py

@@ -17,7 +17,11 @@ from home import home
 # from team_xg_rates import team_xg_rates
 # from gsax_comparison import gsax_comparison
 # from game import game
-# from games import games
+from spray import spray
+from decision_value import decision_value
+from damage import damage
+from batter_scatter import batter_scatter
+from ev_angle import ev_angle
 # from articles import articles
 # from xg_model import xg_model
 
@@ -31,7 +35,11 @@ routes = [
 #     Mount('/skater-xg-percentages', app=on_ice_xgfp),
 #     Mount('/team-xg-rates', app=team_xg_rates),
 #     Mount('/gsax-comparison',app=gsax_comparison),
-#     Mount('/games',app=games),
+    Mount('/spray',app=spray),
+    Mount('/decision_value',app=decision_value),
+    Mount('/damage_model',app=damage),
+    Mount('/batter_scatter',app=batter_scatter),
+    Mount('/ev_angle',app=ev_angle),
 #     Mount('/game/{game_id}',app=game),
 #     Mount('/articles',app=articles),
 #     Mount('/xg-model',app=xg_model)

batter_scatter.py

@@ -0,0 +1,499 @@
+from shiny import App, Inputs, Outputs, Session, reactive, render, req, ui
+import datasets
+from datasets import load_dataset
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import numpy as np
+from scipy.stats import gaussian_kde
+import matplotlib
+from matplotlib.ticker import MaxNLocator
+from matplotlib.gridspec import GridSpec
+from scipy.stats import zscore
+import math
+import matplotlib
+from adjustText import adjust_text
+import matplotlib.ticker as mtick
+from shinywidgets import output_widget, render_widget
+import pandas as pd
+from configure import base_url
+import shinyswatch
+
+
+exit_velo_df_codes_summ_batter = pd.read_csv('summary_batter.csv',index_col=[0])
+#exit_velo_df_codes_summ = pd.read_csv('summary_pitcher.csv',index_col=[0])
+
+exit_velo_df_codes_summ_non_level = pd.read_csv('summary_batter_level.csv',index_col=[0]).reset_index(drop=True)
+
+exit_velo_df_codes_summ_non_level['levels'] = exit_velo_df_codes_summ_non_level.levels.str.split(', ')
+
+exit_velo_df_codes_summ_non_level = exit_velo_df_codes_summ_non_level.rename(columns={'levels':'level'})
+
+
+
+print(exit_velo_df_codes_summ_batter.bb_minus_k_percent)
+
+batter_dict_stat = { 'sweet_spot_percent':{'x_axis':'SweetSpot%','title':'SweetSpot%','flip_p':False,'decimal_format':'percent_1','percent_adjust':100},
+                'max_launch_speed':{'x_axis':'Max Exit Velocity','title':'Max Exit Velocity','flip_p':False,'decimal_format':'string_0','percent_adjust':1},
+                'launch_speed_90':{'x_axis':'90th Percentile EV','title':'90th Percentile EV','flip_p':False,'decimal_format':'string_0','percent_adjust':1},
+                'launch_speed':{'x_axis':'Exit Velocity','title':'Exit Velocity','flip_p':False,'decimal_format':'string_0','percent_adjust':1},
+                'launch_angle':{'x_axis':'Launch Angle','title':'Launch Angle','flip_p':False,'decimal_format':'string_0','percent_adjust':100},
+                'avg':{'x_axis':'AVG','title':'AVG','flip_p':False,'decimal_format':'string_3','percent_adjust':100},
+                'obp':{'x_axis':'OBP','title':'OBP','flip_p':False,'decimal_format':'string_3','percent_adjust':100},
+                'slg':{'x_axis':'SLG','title':'SLG','flip_p':False,'decimal_format':'string_3','percent_adjust':100},
+                'ops':{'x_axis':'OPS','title':'OPS','flip_p':False,'decimal_format':'string_3','percent_adjust':100},
+                'k_percent':{'x_axis':'K%','title':'K%','flip_p':True,'decimal_format':'percent_1','percent_adjust':100},
+                'bb_percent':{'x_axis':'BB%','title':'BB%','flip_p':False,'decimal_format':'percent_1','percent_adjust':100},
+                'bb_over_k_percent':{'x_axis':'BB/K','title':'BB/K','flip_p':False,'decimal_format':'string_1','percent_adjust':100},
+                'bb_minus_k_percent':{'x_axis':'BB%-K%','title':'BB%-K%','flip_p':False,'decimal_format':'percent_1','percent_adjust':100},
+                'csw_percent':{'x_axis':'CSW%','title':'CSW%','flip_p':True,'decimal_format':'percent_1','percent_adjust':100},
+                'woba_percent':{'x_axis':'wOBA','title':'wOBA','flip_p':False,'decimal_format':'string_3','percent_adjust':100},
+                'hard_hit_percent':{'x_axis':'HardHit%','title':'HardHit%','flip_p':False,'decimal_format':'percent_1','percent_adjust':100},
+                'barrel_percent':{'x_axis':'Barrel%','title':'Barrel%','flip_p':False,'decimal_format':'percent_1','percent_adjust':100},
+                'zone_contact_percent':{'x_axis':'Z-Contact%','title':'Z-Contact%','flip_p':False,'decimal_format':'percent_1','percent_adjust':100},
+                'zone_swing_percent':{'x_axis':'Z-Swing%','title':'Z-Swing%','flip_p':False,'decimal_format':'percent_1','percent_adjust':100},
+                'zone_percent':{'x_axis':'Zone%','title':'Zone%','flip_p':False,'decimal_format':'percent_1','percent_adjust':100},
+                'chase_percent':{'x_axis':'O-Swing%','title':'O-Swing%','flip_p':True,'decimal_format':'percent_1','percent_adjust':100},
+                'chase_contact':{'x_axis':'O-Contact%','title':'O-Contact%','flip_p':True,'decimal_format':'percent_1','percent_adjust':100},
+                'swing_percent':{'x_axis':'Swing%','title':'Swing%','flip_p':False,'decimal_format':'percent_1','percent_adjust':100},
+                'whiff_rate':{'x_axis':'Whiff%','title':'Whiff%','flip_p':True,'decimal_format':'percent_1','percent_adjust':100},
+                'swstr_rate':{'x_axis':'SwStr%','title':'SwStr%','flip_p':True,'decimal_format':'percent_1','percent_adjust':100},
+                }
+
+batter_dict_stat_small = { 'sweet_spot_percent':'SweetSpot%',
+                'max_launch_speed':'Max Exit Velocity',
+                'launch_speed_90':'90th Percentile EV',
+                'launch_speed':'Exit Velocity',
+                'launch_angle':'Launch Angle',
+                'avg':'AVG',
+                'obp':'OBP',
+                'slg':'SLG',
+                'ops':'OPS',
+                'k_percent':'K%',
+                'bb_percent':'BB%',
+                'bb_over_k_percent':'BB/K',
+                'bb_minus_k_percent':'BB%-K%',
+                'csw_percent':'CSW%',
+                'woba_percent':'wOBA',
+                'hard_hit_percent':'HardHit%',
+                'barrel_percent':'Barrel%',
+                'zone_contact_percent':'Z-Contact%',
+                'zone_swing_percent':'Z-Swing%',
+                'zone_percent':'Zone%',
+                'chase_percent':'O-Swing%',
+                'chase_contact':'O-Contact%',
+                'swing_percent':'Swing%',
+                'whiff_rate':'Whiff%',
+                'swstr_rate':'SwStr%',
+                }
+
+
+colour_palette = ['#FFB000','#648FFF','#785EF0',
+                  '#DC267F','#FE6100','#3D1EB2','#894D80','#16AA02','#B5592B','#A3C1ED']
+
+level_dict = {'MLB':'MLB','AAA':'AAA','AA':'AA','A+':'A+','A':'A','ROK':'ROK'}
+
+batter_test_df = exit_velo_df_codes_summ_batter.sort_values(by='batter').drop_duplicates(subset='batter_id').reset_index(drop=True)[['batter_id','batter']]#['pitcher'].to_dict()
+batter_test_df = batter_test_df.set_index('batter_id')
+
+
+def decimal_format_assign(x):
+    if x['decimal_format'] == 'percent_1':
+        return mtick.PercentFormatter(1,decimals=1)
+    if x['decimal_format'] == 'string_3':
+        return mtick.FormatStrFormatter('%.3f')
+    if x['decimal_format'] == 'string_0':
+        return mtick.FormatStrFormatter('%.0f')
+    if x['decimal_format'] == 'string_1':
+        return mtick.FormatStrFormatter('%.1f')
+
+
+#test_df =  test_df[test_df.pitcher == 'Chris Bassitt'].append(test_df[test_df.pitcher != 'Chris Bassitt'])
+
+batter_dict = batter_test_df['batter'].to_dict()
+
+exit_velo_df_codes_summ_batter.position = exit_velo_df_codes_summ_batter.position.replace(['LF','RF','CF','TWP'],['OF','OF','OF','DH'])
+exit_velo_df_codes_summ_non_level.position = exit_velo_df_codes_summ_non_level.position.replace(['LF','RF','CF','TWP'],['OF','OF','OF','DH'])
+
+position_list = ['All'] + list(exit_velo_df_codes_summ_batter.position.unique())
+team_list = ['All'] + sorted(list(exit_velo_df_codes_summ_batter.parent_org_abb.unique()))
+
+
+
+def server(input,output,session):
+
+
+    @output
+    @render.plot(alt="A histogram")
+    def plot():
+        sns.set_theme(style="whitegrid", palette="pastel")
+        print(input.level_id())
+        print(input.n())
+        print('we made it here',input.team_id(),input.position_id())
+        if input.group_level():
+            data_df = exit_velo_df_codes_summ_non_level.copy()
+
+            turth_list = []
+            #turth_list_2 = []
+            for x in range(0,len(data_df.level)):
+                turth_list_2 = []
+                for y in range(0,len(data_df.level[x])):
+                    #print(level_list[x][y])
+                    turth_list_2.append(data_df.level[x][y] in input.level_id())
+                turth_list.append(turth_list_2)
+
+            final_check_list = [True if True in x else False for x in turth_list]
+
+
+            data_df = data_df[(data_df.pa >= input.n())&(data_df.age <= input.n_age())&(final_check_list)]
+        
+        
+        else:
+
+
+            data_df = exit_velo_df_codes_summ_batter.copy()
+            data_df = data_df[(data_df.pa >= input.n())&(data_df.age <= input.n_age())&(data_df.level.isin(input.level_id()))]
+            print(data_df)
+            if 'All' in input.team_id():
+                print('nice')#data_df = data_df[(data_df.pa >= input.n())&(data_df.age <= input.n_age())].reset_index(drop=True)
+            
+            else:
+                data_df = data_df[(data_df.parent_org_abb.isin(input.team_id()))].reset_index(drop=True)
+
+            if 'All' in input.position_id():
+                print('nice')#data_df = data_df[(data_df.level.isin(input.level_id()))&(data_df.pa >= input.n())&(data_df.age <= input.n_age())].reset_index(drop=True)
+            
+            else:
+                data_df = data_df[(data_df.position.isin(input.position_id()))].reset_index(drop=True)
+            
+            
+        #print('we made it here')
+        print(data_df)
+        data_df = data_df.sort_values(by='level').reset_index(drop=True)
+        print(batter_dict_stat[input.stat_x()]['flip_p'])
+
+
+
+        x_flip = batter_dict_stat[input.stat_x()]['flip_p']
+        y_flip = batter_dict_stat[input.stat_y()]['flip_p']
+        cbr_flip = batter_dict_stat[input.stat_z()]['flip_p']
+
+        
+
+        data_df[input.stat_x()+'_percent'] = data_df[input.stat_x()].rank(pct=True,ascending=abs(x_flip-1))
+
+        data_df[input.stat_y()+'_percent'] = data_df[input.stat_y()].rank(pct=True,ascending=abs(y_flip-1))
+
+        data_df[input.stat_z()+'_percent'] = data_df[input.stat_z()].rank(pct=True,ascending=abs(cbr_flip-1))
+
+
+
+        fig, ax = plt.subplots(1, 1, figsize=(9, 9))
+
+        #data_df['bb_over_obp'] = data_df['bb']/data_df['k']
+        
+        #data_df[input.stat_z()]= data_df[input.stat_z()].fillna(-100000)
+        
+        
+        if cbr_flip:
+            cmap_hue = matplotlib.colors.LinearSegmentedColormap.from_list("", [colour_palette[0],colour_palette[3],colour_palette[1]])
+            norm = plt.Normalize(data_df[input.stat_z()].min(), data_df[input.stat_z()].max())
+
+        else:
+            cmap_hue = matplotlib.colors.LinearSegmentedColormap.from_list("", [colour_palette[1],colour_palette[3],colour_palette[0]])
+            norm = plt.Normalize(data_df[input.stat_z()].min(), data_df[input.stat_z()].max())
+
+        sm = plt.cm.ScalarMappable(cmap=cmap_hue, norm=norm)
+        print('we made it here')
+
+        # sns.regplot(x = stat_x, y = stat_y, data=data_df, color = colour_palette[6],ax=ax,scatter=False,
+        #             line_kws=dict(alpha=0.3,linewidth=2,zorder=1))
+        # scatter_plot = sns.scatterplot(x = stat_x, y = stat_y, data=data_df, color = colour_palette[0],ax=ax,hue=stat_z,palette=cmap_hue)
+
+
+
+        # r, p = sp.stats.pearsonr(data_df[input.stat_x()], data_df[input.stat_y()])
+        # ax = plt.gca()
+        # # ax.text(.25, 0.3, 'r={:.2f}, p={:.2g}'.format(r, p),
+        # #         transform=ax.transAxes, fontsize=12)
+
+        # ax.annotate('R²={:.2f}'.format(r, p), ( math.ceil(data_df[input.stat_x()].max()*batter_dict_stat[input.stat_x()]['percent_adjust']/5)*5/batter_dict_stat[input.stat_x()]['percent_adjust']*(1-batter_dict_stat[input.stat_x()]['flip_p']), 
+        #                                       math.floor(data_df[input.stat_y()].min()*batter_dict_stat[input.stat_y()]['percent_adjust']/5)*5/batter_dict_stat[input.stat_y()]['percent_adjust']*(1-batter_dict_stat[input.stat_y()]['flip_p'])), 
+        #                                         fontsize=18,fontname='Century Gothic',ha='right')
+
+        if input.group_level():
+            scatter = sns.scatterplot(x = input.stat_x(), y = input.stat_y(), data=data_df, color = '#b3b3b3')
+            #ax.get_legend().remove()
+            scatter = sns.scatterplot(x = input.stat_x(), y = input.stat_y(), data=data_df, color = colour_palette[0],ax=ax,hue=input.stat_z(),palette=cmap_hue)
+        else:
+            scatter = sns.scatterplot(x = input.stat_x(), y = input.stat_y(), data=data_df, color = '#b3b3b3',style='level')    
+            #ax.get_legend().remove()
+            scatter = sns.scatterplot(x = input.stat_x(), y = input.stat_y(), data=data_df, color = colour_palette[0],ax=ax,hue=input.stat_z(),palette=cmap_hue,style='level')
+        sns.set_theme(style="whitegrid", palette="pastel")
+
+        fig.set_facecolor('#F0F0F0')
+        ax.set_facecolor('white')
+
+        print('we made it here')
+        # for i in range(0,len(pitch_group_unique)):
+        #     data_df = elly_zone_df[elly_zone_df.pitch_group==pitch_group_unique[i]]
+        #     len_df.append(len(data_df))
+        #     sns.lineplot(x=range(1,len(data_df)+1),y=data_df.swings.rolling(window=rolling_window_input).sum()/data_df.pitches.rolling(window=rolling_window_input).sum(),color=colour_palette[i],linewidth=3,ax=ax,
+        #                  label=f'{pitch_group_unique[i]} (Season Average {float(data_df.swings.sum()/data_df.pitches.sum()):.1%})',zorder=i+10)
+        #     ax.hlines(xmin=0,xmax=len(elly_zone_df),y=data_df.swings.sum()/data_df.pitches.sum(),color=colour_palette[i],linewidth=3,linestyle='-.',alpha=0.4,zorder=i)
+
+        ts=[]
+        print(input.player_id())
+
+        print(len(data_df))
+        if input.names():
+            for i in range(len(data_df)):
+                if (data_df[input.stat_x()+'_percent'][i] < input.n_percent_bot_x()  or data_df[input.stat_x()+'_percent'][i] > 1 - input.n_percent_top_x() ) \
+                or (data_df[input.stat_y()+'_percent'][i] < input.n_percent_bot_y()  or data_df[input.stat_y()+'_percent'][i] > 1 -input.n_percent_top_y()) \
+                or (data_df[input.stat_z()+'_percent'][i] < input.n_percent_bot_z()  or data_df[input.stat_z()+'_percent'][i] > 1 -input.n_percent_top_z() )\
+                or (str(data_df.batter_id[i]) in (input.player_id())):
+                    # print(data_df.batter[i])
+                    # ax.annotate(data_df.batter[i], xy=((data_df[input.stat_x()][i])+0.025/batter_dict_stat[input.stat_x()]['percent_adjust'], data_df[input.stat_y()][i]+0.01/batter_dict_stat[input.stat_x()]['percent_adjust']), xytext=(-20,20), 
+                    # textcoords='offset points', ha='center', va='bottom',fontsize=7,
+                    # bbox=dict(boxstyle='round,pad=0', fc=colour_palette[6], alpha=0.0),
+                    # arrowprops=dict(arrowstyle='->', connectionstyle="angle,angleA=-90,angleB=-10,rad=2", 
+                    #                 color=colour_palette[8]))
+                    
+                    #if data_df['batter'][i] != 'Jo Adell':
+                    # ax.annotate(data_df.batter[i], (data_df[input.stat_x()][i]-len(data_df.batter[i])*0.00025, data_df[input.stat_y()][i]+0.001),fontsize=8)
+                    ts.append(ax.text(data_df[input.stat_x()][i], data_df[input.stat_y()][i], data_df.batter[i],fontsize=8))
+
+
+
+        ax.hlines(xmin=(math.floor((data_df[input.stat_x()].min()*batter_dict_stat[input.stat_x()]['percent_adjust']-0.01)/5))*5/batter_dict_stat[input.stat_x()]['percent_adjust'],
+                    xmax= (math.ceil((data_df[input.stat_x()].max()*batter_dict_stat[input.stat_x()]['percent_adjust']+0.01)/5))*5/batter_dict_stat[input.stat_x()]['percent_adjust'],
+                    y=data_df[input.stat_y()].mean(),color='gray',linewidth=3,linestyle='dotted',alpha=0.4)
+
+        print('we made it here')
+
+        ax.vlines(ymin=(math.floor((data_df[input.stat_y()].min()*batter_dict_stat[input.stat_y()]['percent_adjust']-0.01)/5))*5/batter_dict_stat[input.stat_y()]['percent_adjust'],
+                    ymax= (math.ceil((data_df[input.stat_y()].max()*batter_dict_stat[input.stat_y()]['percent_adjust']+0.01)/5))*5/batter_dict_stat[input.stat_y()]['percent_adjust'],
+                    x=data_df[input.stat_x()].mean(),color='gray',linewidth=3,linestyle='dotted',alpha=0.4)
+
+        print(data_df[input.stat_x()].min())
+        print(batter_dict_stat[input.stat_x()]['percent_adjust'])
+        print((math.floor((data_df[input.stat_x()].min()*batter_dict_stat[input.stat_x()]['percent_adjust']-0.01)/5))*5/batter_dict_stat[input.stat_x()]['percent_adjust'])
+
+
+        ax.set_xlim((math.floor((data_df[input.stat_x()].min()*batter_dict_stat[input.stat_x()]['percent_adjust'])/5))*5/batter_dict_stat[input.stat_x()]['percent_adjust'],
+                    (math.ceil((data_df[input.stat_x()].max()*batter_dict_stat[input.stat_x()]['percent_adjust'])/5))*5/batter_dict_stat[input.stat_x()]['percent_adjust'])
+
+
+        ax.set_ylim((math.floor((data_df[input.stat_y()].min()*batter_dict_stat[input.stat_y()]['percent_adjust'])/5))*5/batter_dict_stat[input.stat_y()]['percent_adjust'],
+                    (math.ceil((data_df[input.stat_y()].max()*batter_dict_stat[input.stat_y()]['percent_adjust'])/5))*5/batter_dict_stat[input.stat_y()]['percent_adjust'])
+       
+
+
+        title_level = str([x .strip("\'")for x in input.level_id()]).strip('[').strip(']').replace("'",'')
+
+        if title_level == 'AAA, AA, A+, A':
+            title_level='MiLB'
+        #title_level = input.level_id()[0]
+        if input.n_age() >= 50:
+            title_spot = f'{title_level} Batter {batter_dict_stat[input.stat_y()]["title"]} vs {batter_dict_stat[input.stat_x()]["title"]} (min. {input.n()} PA)'
+        
+        else:
+            title_spot = f'{title_level} Batter {batter_dict_stat[input.stat_y()]["title"]} vs {batter_dict_stat[input.stat_x()]["title"]} (min. {input.n()} PA, Max Age {input.n_age()})'
+
+        ax.set_title(title_spot, fontsize=24/(len(title_spot)*0.03),fontname='Century Gothic')
+        # #vals = ax.get_yticks()
+        ax.set_xlabel(batter_dict_stat[input.stat_x()]['x_axis'], fontsize=16,fontname='Century Gothic')
+        ax.set_ylabel(batter_dict_stat[input.stat_y()]['x_axis'], fontsize=16,fontname='Century Gothic')
+        
+
+        if input.group_level():
+            ax.get_legend().remove()
+
+        if not input.group_level():
+            if len(input.level_id()) > 1:
+                h,l = scatter.get_legend_handles_labels()
+                l[-(len(input.level_id())+1)] = 'Level'
+                ax.legend(h[-(len(input.level_id())+1):],l[-(len(input.level_id())+1):], borderaxespad=0.1,loc=0)
+
+            else:
+                ax.get_legend().remove()
+
+        #plt.show(g)
+        # ax.figure.colorbar(sm, ax=ax)
+        
+        cbar  = ax.figure.colorbar(sm, ax=ax,format=decimal_format_assign(x=batter_dict_stat[input.stat_z()]),orientation='vertical',aspect=30)
+        cbar.set_label(batter_dict_stat[input.stat_z()]['x_axis'])
+        #fig.axes[0].invert_yaxis()
+        print('we made it here5')
+        fig.subplots_adjust(wspace=.02, hspace=.02)
+        # ax.xaxis.set_major_formatter(FuncFormatter(lambda x, _: int(x)))
+        #ax.set_yticks([0,0.1,0.2,0.3,0.4,0.5])
+        # fig.colorbar(plot_dist, ax=ax)
+        # fig.colorbar(plot_dist)
+
+        if batter_dict_stat[input.stat_x()]['flip_p']:
+            fig.axes[0].invert_xaxis()
+
+        if batter_dict_stat[input.stat_y()]['flip_p']:
+            fig.axes[0].invert_yaxis()
+
+
+        # ax.xaxis.set_major_formatter(mtick.PercentFormatter(1,decimals=0))
+        # ax.yaxis.set_major_formatter(mtick.PercentFormatter(1))
+
+        
+        
+        
+
+        print('we made it here6')
+
+        ax.xaxis.set_major_formatter(decimal_format_assign(x=batter_dict_stat[input.stat_x()]))
+        ax.yaxis.set_major_formatter(decimal_format_assign(x=batter_dict_stat[input.stat_y()]))
+
+
+        print('we made it here7')
+        # ax.text(0.5, 0.5, '/u/tomstoms', transform=ax.transAxes,
+        #         fontsize=60, color='gray', alpha=0.075,
+        #         ha='center', va='center', rotation=45)
+
+        print(ts)
+        adjust_text(ts,
+                    arrowprops=dict(arrowstyle="-", color=colour_palette[4], lw=1),ax=ax)
+
+        #ax.legend(fontsize='16')
+        fig.text(x=0.03,y=0.02,s='By: @TJStats',fontname='Century Gothic')
+        fig.text(x=1-0.03,y=0.02,s='Data: MLB',ha='right',fontname='Century Gothic')
+        fig.tight_layout()
+        #matplotlib.rcParams["figure.dpi"] = 600
+        #plt.show()
+
+
+batter_scatter = 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.navset_tab(
+        ui.nav_control(
+             ui.a(
+                "Home",
+                href="home/"
+            ),
+        ),
+        ui.nav_menu(
+            "Batter Charts",
+            ui.nav_control(
+             ui.a(
+                "Spray",
+                href="spray/"
+            ),
+            ui.a(
+                "Decision Value",
+                href="decision_value/"
+            ),
+            ui.a(
+                "Damage Model",
+                href="damage_model/"
+            ),
+            ui.a(
+                "Batter Scatter",
+                href="batter_scatter/"
+            ),
+            ui.a(
+                "EV vs LA Plot",
+                href="ev_angle/"
+            )
+        ),
+        ),
+        ui.nav_menu(
+            "Goalie Charts",
+            ui.nav_control(
+             ui.a(
+                "GSAx Timeline",
+                href="gsax-timeline/"
+            ),
+             ui.a(
+                "GSAx Leaderboard",
+                href="gsax-leaderboard/"
+            ),
+             ui.a(
+                "GSAx Comparison",
+                href="gsax-comparison/"
+            )
+        ),
+        ),ui.nav_menu(
+            "Team Charts",
+            ui.nav_control(
+             ui.a(
+                "Team xG Rates",
+                href="team-xg-rates/"
+            ),
+        ),
+        ),ui.nav_control(
+             ui.a(
+                "Games",
+                href="games/"
+            ),
+        ),ui.nav_control(
+             ui.a(
+                "About",
+                href="about/"
+            ),
+        ),ui.nav_control(
+             ui.a(
+                "Articles",
+                href="articles/"
+            ),
+        )),ui.row(
+    ui.layout_sidebar(
+        
+   
+
+      ui.panel_sidebar(
+        #ui.input_select("id", "Select Batter",batter_dict,selected=675911,width=1,size=1),
+        ui.row(
+            ui.column(4,ui.input_select("level_id", "Select Level",level_dict,width=1,size=1,multiple=True,selected='MLB',selectize=True),),
+            ui.column(4,ui.input_select("team_id", "Select Team",team_list,width=1,size=1,multiple=True,selected='All',selectize=True),),
+            ui.column(4,ui.input_select("position_id", "Select Position",position_list,width=1,size=1,selected='All',multiple=True,selectize=True))),
+        ui.row(
+            ui.column(6,ui.input_numeric("n", "Minimum PA", value=100)),
+            ui.column(6,ui.input_numeric("n_age", "Maximum Age", value=50))),
+        ui.row(
+            ui.column(4,ui.input_select("stat_x", "X-Axis",batter_dict_stat_small,selected='k_percent',width=1,size=1)),
+            ui.column(4,ui.input_select("stat_y", "Y-Axis",batter_dict_stat_small,selected='bb_percent',width=1,size=1)),
+            ui.column(4,ui.input_select("stat_z", "Colour-Bar Axis",batter_dict_stat_small,selected='bb_over_k_percent',width=1,size=1))),
+       
+        ui.row(
+            ui.column(6,ui.input_numeric("n_percent_top_x", "Top 'n' Percentile X-Labels", value=0.01)),
+            ui.column(6,ui.input_numeric("n_percent_bot_x", "Bottom 'n' Percentile X-Labels", value=0.01))),
+        ui.row(
+            ui.column(6,ui.input_numeric("n_percent_top_y", "Top 'n' Percentile Y-Labels", value=0.01)),
+            ui.column(6,ui.input_numeric("n_percent_bot_y", "Bottom 'n' Percentile Y-Labels", value=0.01))),
+        ui.row(
+            ui.column(6,ui.input_numeric("n_percent_top_z", "Top 'n' Percentile Z-Labels", value=0.01)),
+            ui.column(6,ui.input_numeric("n_percent_bot_z", "Bottom 'n' Percentile Z-Labels", value=0.01))),
+
+        ui.input_select("player_id", "Label Player",batter_dict,width=1,size=1,multiple=True,selectize=True),
+        ui.row(
+            ui.input_switch("names", "Toggle Names"),
+            ui.input_switch("group_level", "Group Levels")),
+     ),
+
+      ui.panel_main(
+        ui.output_plot("plot",height = "1000px",width="1000px")
+      ,
+    ),
+    )),)),server)

damage.py

@@ -0,0 +1,610 @@
+from shiny import App, Inputs, Outputs, Session, reactive, render, req, ui
+import datasets
+from datasets import load_dataset
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import numpy as np
+from scipy.stats import gaussian_kde
+import matplotlib
+from matplotlib.ticker import MaxNLocator
+from matplotlib.gridspec import GridSpec
+from scipy.stats import zscore
+import math
+import matplotlib
+from adjustText import adjust_text
+import matplotlib.ticker as mtick
+from shinywidgets import output_widget, render_widget
+import pandas as pd
+from configure import base_url
+import shinyswatch
+
+### Import Datasets
+dataset = load_dataset('nesticot/mlb_data', data_files=['mlb_pitch_data_2023.csv' ])
+dataset_train = dataset['train']
+df_2023 = dataset_train.to_pandas().set_index(list(dataset_train.features.keys())[0]).reset_index(drop=True)
+print(df_2023)
+### Normalize Hit Locations
+
+df_2023['season'] = df_2023['game_date'].str[0:4].astype(int)
+# df_2023['hit_x'] = df_2023['hit_x'] - df_2023['hit_x'].median()
+# df_2023['hit_y'] = -df_2023['hit_y']+df_2023['hit_y'].quantile(0.9999)
+
+df_2023['hit_x'] = df_2023['hit_x'] - 126#df_2023['hit_x'].median()
+df_2023['hit_y'] = -df_2023['hit_y']+204.5#df_2023['hit_y'].quantile(0.9999)
+
+df_2023['hit_x_og'] = df_2023['hit_x']
+df_2023.loc[df_2023['batter_hand'] == 'R','hit_x'] = -1*df_2023.loc[df_2023['batter_hand'] == 'R','hit_x']
+df_2023['h_la'] = np.arctan(df_2023['hit_x'] / df_2023['hit_y'])*180/np.pi
+conditions_ss = [
+    (df_2023['h_la']<-15),
+    (df_2023['h_la']<15)&(df_2023['h_la']>=-15),
+    (df_2023['h_la']>=15)
+]
+
+choices_ss = ['Oppo','Straight','Pull']
+df_2023['traj'] = np.select(conditions_ss, choices_ss, default=np.nan)
+df_2023['bip'] = [1 if x > 0  else np.nan for x in df_2023['launch_speed']]
+
+conditions_woba = [
+        (df_2023['event_type']=='walk'),
+        (df_2023['event_type']=='hit_by_pitch'),
+        (df_2023['event_type']=='single'),
+        (df_2023['event_type']=='double'),
+        (df_2023['event_type']=='triple'),
+        (df_2023['event_type']=='home_run'),
+    ]
+
+
+choices_woba = [1,
+                    1,
+                    1,
+                    2,
+                    3,
+                    4]
+
+
+# choices_woba = [0.698,
+#                     0.728,
+#                     0.887,
+#                     1.253,
+#                     1.583,
+#                     2.027]
+
+df_2023['woba'] = np.select(conditions_woba, choices_woba, default=0)
+
+choices_woba_train = [1,
+                    1,
+                    1,
+                    2,
+                    3,
+                    4]
+
+df_2023['woba_train'] = np.select(conditions_woba, choices_woba_train, default=0)
+
+
+df_2023_bip = df_2023[~df_2023['bip'].isnull()].dropna(subset=['h_la','launch_angle'])
+df_2023_bip['h_la'] = df_2023_bip['h_la'].round(0)
+
+
+df_2023_bip['season'] = df_2023_bip['game_date'].str[0:4].astype(int)
+
+df_2023_bip = df_2023[~df_2023['bip'].isnull()].dropna(subset=['launch_angle','bip'])
+df_2023_bip_train = df_2023_bip[df_2023_bip['season'] == 2023]
+
+batter_dict = df_2023_bip.sort_values('batter_name').set_index('batter_id')['batter_name'].to_dict()
+
+features = ['launch_angle','launch_speed','h_la']
+target = ['woba_train']
+
+df_2023_bip_train = df_2023_bip_train.dropna(subset=features)
+
+import joblib
+# # Dump the model to a file named 'model.joblib'
+model = joblib.load('xtb_model.joblib')
+
+
+df_2023_bip_train['y_pred'] = [sum(x) for x in model.predict_proba(df_2023_bip_train[features]) * ([0,1,2,3,4])]
+# df_2023_bip_train['y_pred_noh'] = [sum(x) for x in model_noh.predict_proba(df_2023_bip_train[['launch_angle','launch_speed']]) * ([0,0.887,1.253,1.583,2.027])]
+
+df_2023_output = df_2023_bip_train.groupby(['batter_id','batter_name']).agg(
+    bip = ('y_pred','count'),
+    y_pred = ('y_pred','sum'),
+    slgcon = ('woba','mean'),
+    xslgcon = ('y_pred','mean'),
+    launch_speed = ('launch_speed','mean'),
+    launch_angle_std = ('launch_angle','median'),
+    h_la_std = ('h_la','mean'))
+
+df_2023_output_copy = df_2023_output.copy()
+# df_2023_output = df_2023_output[df_2023_output['bip'] > 100]
+# df_2023_output[df_2023_output['bip'] > 100].sort_values(by='h_la_std',ascending=True).head(20)
+
+import pandas as pd
+import numpy as np
+
+
+# Create grid coordinates
+x = np.arange(30, 121,1 )
+y = np.arange(-30, 61,1 )
+z = np.arange(-45, 46,1 )
+
+# Create a meshgrid
+X, Y, Z = np.meshgrid(x, y, z, indexing='ij')
+# Flatten the meshgrid to get x and y coordinates
+x_flat = X.flatten()
+y_flat = Y.flatten()
+z_flat = Z.flatten()
+
+# Create a DataFrame
+df = pd.DataFrame({'launch_speed': x_flat, 'launch_angle': y_flat,'h_la':z_flat})
+
+df['y_pred']  = [sum(x) for x in model.predict_proba(df[features]) * ([0,1,2,3,4])]
+
+
+import matplotlib
+
+colour_palette = ['#FFB000','#648FFF','#785EF0',
+                  '#DC267F','#FE6100','#3D1EB2','#894D80','#16AA02','#B5592B','#A3C1ED']
+
+cmap_hue = matplotlib.colors.LinearSegmentedColormap.from_list("", [colour_palette[1],'#ffffff',colour_palette[0]])
+cmap_hue2 = matplotlib.colors.LinearSegmentedColormap.from_list("",['#ffffff',colour_palette[0]])
+
+
+from matplotlib.pyplot import text
+import inflect
+from scipy.stats import percentileofscore
+p = inflect.engine()
+
+
+
+
+def server(input,output,session):
+
+
+    @output
+    @render.plot(alt="hex_plot")
+    def hex_plot():
+
+        if input.batter_id() is "":
+            fig = plt.figure(figsize=(12, 12))
+            fig.text(s='Please Select a Batter',x=0.5,y=0.5)
+            return
+        
+        batter_select_id = int(input.batter_id())
+        # batter_select_name = 'Edouard Julien'
+        quant = int(input.quant())/100  
+        df_batter_og = df_2023_bip_train[df_2023_bip_train['batter_id']==batter_select_id]
+        # df_batter_og = df_2023_bip_train[df_2023_bip_train['batter_name']==batter_select_name]
+        df_batter = df_batter_og[df_batter_og['launch_speed'] >= df_batter_og['launch_speed'].quantile(quant)]
+        # df_batter_best_speed = df_batter['launch_speed'].mean().round()
+
+        # df_bip_league = df_2023_bip_train[df_2023_bip_train['launch_speed'] >= df_2023_bip_train['launch_speed'].quantile(quant)]
+
+        import pandas as pd
+        import numpy as np
+
+
+        # Create grid coordinates
+        #x = np.arange(30, 121,1 )
+        y_b = np.arange(df_batter['launch_angle'].median()-df_batter['launch_angle'].std(),
+                df_batter['launch_angle'].median()+df_batter['launch_angle'].std(),1 )
+
+        z_b = np.arange(df_batter['h_la'].median()-df_batter['h_la'].std(),
+                df_batter['h_la'].median()+df_batter['h_la'].std(),1 )
+
+        # Create a meshgrid
+        Y_b, Z_b = np.meshgrid( y_b,z_b, indexing='ij')
+        # Flatten the meshgrid to get x and y coordinates
+
+        y_flat_b = Y_b.flatten()
+        z_flat_b = Z_b.flatten()
+
+        # Create a DataFrame
+        df_batter_base = pd.DataFrame({'launch_angle': y_flat_b,'h_la':z_flat_b,'c':[0]*len(y_flat_b)})
+
+        # df_batter_base['y_pred']  = [sum(x) for x in model.predict_proba(df_batter_base[features]) * ([0,1,2,3,4])]
+
+        from matplotlib.gridspec import GridSpec
+        # fig,ax = plt.subplots(figsize=(12, 12),dpi=150)
+        fig = plt.figure(figsize=(12,12))
+        gs = GridSpec(4, 3, height_ratios=[0.5,10,1.5,0.2], width_ratios=[0.05,0.9,0.05])
+
+        axheader = fig.add_subplot(gs[0, :])
+        ax10 = fig.add_subplot(gs[1, 0])
+        ax = fig.add_subplot(gs[1, 1])  # Subplot at the top-right position
+        ax12 = fig.add_subplot(gs[1, 2])
+        ax2_ = fig.add_subplot(gs[2, :])
+        axfooter1 = fig.add_subplot(gs[-1, :])
+
+        axheader.axis('off')
+        ax10.axis('off')
+        ax12.axis('off')
+        ax2_.axis('off')
+        axfooter1.axis('off')
+
+
+
+        extents = [-45,45,-30,60]
+
+        def hexLines(a=None,i=None,off=[0,0]):
+                '''regular hexagon segment lines as `(xy1,xy2)` in clockwise
+                order with points in line sorted top to bottom
+                for irregular hexagon pass both `a` (vertical) and `i` (horizontal)'''
+                if a is None: a = 2 / np.sqrt(3) * i;
+                if i is None: i = np.sqrt(3) / 2 * a;
+                h  = a / 2
+                xy = np.array([ [ [ 0, a], [ i, h] ],
+                                [ [ i, h], [ i,-h] ],
+                                [ [ i,-h], [ 0,-a] ],
+                                [ [-i,-h], [ 0,-a] ], #flipped
+                                [ [-i, h], [-i,-h] ], #flipped
+                                [ [ 0, a], [-i, h] ]  #flipped
+                                ])
+                return xy+off;
+
+
+        h   = ax.hexbin(x=df_batter_base['h_la'],
+                y=df_batter_base['launch_angle'],
+                gridsize=25,
+                edgecolors='k',
+                extent=extents,mincnt=1,lw=2,zorder=-3,)
+
+        # cfg = {**cfg,'vmin':h.get_clim()[0], 'vmax':h.get_clim()[1]}
+        # plt.hexbin( ec="black"  ,lw=6,zorder=4,mincnt=2,**cfg,alpha=0.1)
+        # plt.hexbin( ec="#ffffff",lw=1,zorder=5,mincnt=2,**cfg,alpha=0.1)
+
+
+        ax.hexbin(x=df[(df['launch_angle']>=-30)&(df['launch_angle']<=60)&(df['launch_speed']>=df_batter['launch_speed'].median())&(df['launch_speed']<=df_batter['launch_speed'].max())]['h_la'],
+                y=df[(df['launch_angle']>=-30)&(df['launch_angle']<=60)&(df['launch_speed']>=df_batter['launch_speed'].median())&(df['launch_speed']<=df_batter['launch_speed'].max())]['launch_angle'],
+                C=df[(df['launch_angle']>=-30)&(df['launch_angle']<=60)&(df['launch_speed']>=df_batter['launch_speed'].median())&(df['launch_speed']<=df_batter['launch_speed'].max())]['y_pred'],
+                gridsize=25,
+                vmin=0,
+                vmax=4,
+                cmap=cmap_hue2,
+                extent=extents,zorder=-3)
+
+
+        # Get the counts and centers of the hexagons
+        counts = ax.hexbin(x=df[(df['launch_angle']>=-30)&(df['launch_angle']<=60)&(df['launch_speed']>=df_batter['launch_speed'].median())&(df['launch_speed']<=df_batter['launch_speed'].max())]['h_la'],
+                y=df[(df['launch_angle']>=-30)&(df['launch_angle']<=60)&(df['launch_speed']>=df_batter['launch_speed'].median())&(df['launch_speed']<=df_batter['launch_speed'].max())]['launch_angle'],
+                C=df[(df['launch_angle']>=-30)&(df['launch_angle']<=60)&(df['launch_speed']>=df_batter['launch_speed'].median())&(df['launch_speed']<=df_batter['launch_speed'].max())]['y_pred'],
+                gridsize=25,
+                vmin=0,
+                vmax=4,
+                cmap=cmap_hue2,
+                extent=extents).get_array()
+
+        bin_centers = ax.hexbin(x=df[(df['launch_angle']>=-30)&(df['launch_angle']<=60)&(df['launch_speed']>=df_batter['launch_speed'].median())&(df['launch_speed']<=df_batter['launch_speed'].max())]['h_la'],
+                y=df[(df['launch_angle']>=-30)&(df['launch_angle']<=60)&(df['launch_speed']>=df_batter['launch_speed'].median())&(df['launch_speed']<=df_batter['launch_speed'].max())]['launch_angle'],
+                C=df[(df['launch_angle']>=-30)&(df['launch_angle']<=60)&(df['launch_speed']>=df_batter['launch_speed'].median())&(df['launch_speed']<=df_batter['launch_speed'].max())]['y_pred'],
+                gridsize=25,
+                vmin=0,
+                vmax=4,
+                cmap=cmap_hue2,
+                extent=extents).get_offsets()
+
+        # Add text with the values of "C" to each hexagon
+        for count, (x, y) in zip(counts, bin_centers):
+            if count >= 1:
+                ax.text(x, y, f'{count:.1f}', color='black', ha='center', va='center',fontsize=7)
+
+
+
+        #get hexagon centers that should be highlighted
+        verts = h.get_offsets()
+        cnts  = h.get_array()
+        highl = verts[cnts > .5*cnts.max()]
+
+        #create hexagon lines
+        a = ((verts[0,1]-verts[1,1])/3).round(6)
+        i = ((verts[1:,0]-verts[:-1,0])/2).round(6)
+        i = i[i>0][0]
+        lines = np.concatenate([hexLines(a,i,off) for off in highl])
+
+        #select contour lines and draw
+        uls,c = np.unique(lines.round(4),axis=0,return_counts=True)
+        for l in uls[c==1]: ax.plot(*l.transpose(),'w-',lw=2,scalex=False,scaley=False,color=colour_palette[1],zorder=100)
+
+
+        # Plot filled hexagons
+        for hc in highl:
+                hx = hc[0] + np.array([0, i, i, 0, -i, -i])
+                hy = hc[1] + np.array([a, a/2, -a/2, -a, -a/2, a/2])
+                ax.fill(hx, hy, color=colour_palette[1], alpha=0.15, edgecolor=None)  # Adjust color and alpha as needed
+
+        # # Create grid coordinates
+        # #x = np.arange(30, 121,1 )
+        # y_b = np.arange(df_bip_league['launch_angle'].median()-df_bip_league['launch_angle'].std(),
+        #               df_bip_league['launch_angle'].median()+df_bip_league['launch_angle'].std(),1 )
+
+        # z_b = np.arange(df_bip_league['h_la'].median()-df_bip_league['h_la'].std(),
+        #               df_bip_league['h_la'].median()+df_bip_league['h_la'].std(),1 )
+
+        # # Create a meshgrid
+        # Y_b, Z_b = np.meshgrid( y_b,z_b, indexing='ij')
+        # # Flatten the meshgrid to get x and y coordinates
+
+        # y_flat_b = Y_b.flatten()
+        # z_flat_b = Z_b.flatten()
+
+        # # Create a DataFrame
+        # df_league_base = pd.DataFrame({'launch_angle': y_flat_b,'h_la':z_flat_b,'c':[0]*len(y_flat_b)})
+
+        # h_league   = ax.hexbin(x=df_league_base['h_la'],
+        #           y=df_league_base['launch_angle'],
+        #           gridsize=25,
+        #           edgecolors=colour_palette[1],
+        #           extent=extents,mincnt=1,lw=2,zorder=-3,)
+
+        # #get hexagon centers that should be highlighted
+        # verts = h_league.get_offsets()
+        # cnts  = h_league.get_array()
+        # highl = verts[cnts > .5*cnts.max()]
+
+        # #create hexagon lines
+        # a = ((verts[0,1]-verts[1,1])/3).round(6)
+        # i = ((verts[1:,0]-verts[:-1,0])/2).round(6)
+        # i = i[i>0][0]
+        # lines = np.concatenate([hexLines(a,i,off) for off in highl])
+
+        # #select contour lines and draw
+        # uls,c = np.unique(lines.round(4),axis=0,return_counts=True)
+        # for l in uls[c==1]: ax.plot(*l.transpose(),'w-',lw=2,scalex=False,scaley=False,color=colour_palette[3],zorder=99)
+
+
+        axheader.text(s=f"{df_batter['batter_name'].values[0]} - {int(quant*100)}th% EV and Greater Batted Ball Tendencies",x=0.5,y=0.2,fontsize=20,ha='center',va='bottom')
+        axheader.text(s=f"2023 Season",x=0.5,y=-0.1,fontsize=14,ha='center',va='top')
+
+        ax.set_xlabel(f"Horizontal Spray Angle (°)",fontsize=12)
+        ax.set_ylabel(f"Vertical Launch Angle (°)",fontsize=12)
+
+        ax2_.text(x=0.5,
+                y=0.0,
+
+                s="Notes:\n" \
+                f"- {int(quant*100)}th% EV and Greater BBE is defined as a batter's top {100 - int(quant*100)}% hardest hit BBE\n" \
+                f"- Colour Scale and Number Labels Represents the Expected Total Bases for a batter's range of Best Speeds\n" \
+                f"- Shaded Area Represents the 2-D Region bounded by ±1σ Launch Angle and Horizontal Spray Angle on batter's Best Speed BBE\n"\
+                f"- {df_batter['batter_name'].values[0]} {int(quant*100)}th% EV and Greater BBE Range from {df_batter['launch_speed'].min():.0f} to {df_batter['launch_speed'].max():.0f} mph ({len(df_batter)} BBE)\n"\
+                f"- Positive Horizontal Spray Angle Represents a BBE hit in same direction as batter handedness (i.e. Pulled)" ,
+
+                fontsize=11,
+                fontstyle='oblique',
+                va='bottom',
+                ha='center',
+                bbox=dict(facecolor='white', edgecolor='black'),ma='left')
+
+        axfooter1.text(0.05, 0.5, "By: Thomas Nestico\n      @TJStats",ha='left', va='bottom',fontsize=12)
+        axfooter1.text(0.95, 0.5, "Data: MLB",ha='right', va='bottom',fontsize=12)
+
+        if df_batter['batter_hand'].values[0] == 'R':
+                ax.invert_xaxis()
+        ax.grid(False)
+        ax.axis('equal')
+        # Adjusting subplot to center it within the figure
+        fig.subplots_adjust(left=0.01, right=0.99, top=0.975, bottom=0.025)
+
+        #ax.text(f"Vertical Spray Angle (°)")
+
+
+    @output
+    @render.plot(alt="roll_plot")
+    def roll_plot():
+          # player_select = 'Nolan Gorman'
+        # player_select_full =player_select
+
+        if input.batter_id() is "":
+            fig = plt.figure(figsize=(12, 12))
+            fig.text(s='Please Select a Batter',x=0.5,y=0.5)
+            return
+
+        # df_will = df_model_2023[df_model_2023.batter_name == player_select].sort_values(by=['game_date','start_time'])
+        # df_will = df_will[df_will['is_swing'] != 1]
+        batter_select_id = int(input.batter_id())
+        # batter_select_name = 'Edouard Julien'
+        df_batter_og = df_2023_bip_train[df_2023_bip_train['batter_id']==batter_select_id]
+        batter_select_name = df_batter_og['batter_name'].values[0]
+        win = min(int(input.rolling_window()),len(df_batter_og))
+        df_2023_output = df_2023_output_copy[df_2023_output_copy['bip'] >= win]
+        sns.set_theme(style="whitegrid", palette="pastel")
+        #fig, ax = plt.subplots(1, 1, figsize=(10, 10),dpi=300)
+
+        from matplotlib.gridspec import GridSpec
+        # fig,ax = plt.subplots(figsize=(12, 12),dpi=150)
+        fig = plt.figure(figsize=(12,12))
+        gs = GridSpec(3, 3, height_ratios=[0.3,10,0.2], width_ratios=[0.01,2,0.01])
+
+        axheader = fig.add_subplot(gs[0, :])
+        ax10 = fig.add_subplot(gs[1, 0])
+        ax = fig.add_subplot(gs[1, 1])  # Subplot at the top-right position
+        ax12 = fig.add_subplot(gs[1, 2])
+        axfooter1 = fig.add_subplot(gs[-1, :])
+
+        axheader.axis('off')
+        ax10.axis('off')
+        ax12.axis('off')
+        axfooter1.axis('off')
+
+
+        sns.lineplot( x= range(win,len(df_batter_og.y_pred.rolling(window=win).mean())+1),
+                y= df_batter_og.y_pred.rolling(window=win).mean().dropna(),
+                color=colour_palette[0],linewidth=2,ax=ax)
+
+        ax.hlines(y=df_batter_og.y_pred.mean(),xmin=win,xmax=len(df_batter_og),color=colour_palette[0],linestyle='--',
+                label=f'{batter_select_name} Average: {df_batter_og.y_pred.mean():.3f} xSLGCON ({p.ordinal(int(np.around(percentileofscore(df_2023_output["xslgcon"],df_batter_og.y_pred.mean(), kind="strict"))))} Percentile)')
+
+        # ax.hlines(y=df_model_2023.y_pred_no_swing.std()*100,xmin=win,xmax=len(df_will))
+
+        # sns.scatterplot( x= [976],
+        #               y= df_will.y_pred.rolling(window=win).mean().min()*100,
+        #               color=colour_palette[0],linewidth=2,ax=ax,zorder=100,s=100,edgecolor=colour_palette[7])
+
+
+        ax.hlines(y=df_2023_bip_train['y_pred'].mean(),xmin=win,xmax=len(df_batter_og),color=colour_palette[1],linestyle='-.',alpha=1,
+                label = f'MLB Average: {df_2023_bip_train["y_pred"].mean():.3f} xSLGCON')
+
+        ax.legend()
+
+        hard_hit_dates = [df_2023_output['xslgcon'].quantile(0.9),
+                        df_2023_output['xslgcon'].quantile(0.75),
+                        df_2023_output['xslgcon'].quantile(0.25),
+                        df_2023_output['xslgcon'].quantile(0.1)]
+
+
+
+        ax.hlines(y=df_2023_output['xslgcon'].quantile(0.9),xmin=win,xmax=len(df_batter_og),color=colour_palette[2],linestyle='dotted',alpha=0.5,zorder=1)
+        ax.hlines(y=df_2023_output['xslgcon'].quantile(0.75),xmin=win,xmax=len(df_batter_og),color=colour_palette[3],linestyle='dotted',alpha=0.5,zorder=1)
+        ax.hlines(y=df_2023_output['xslgcon'].quantile(0.25),xmin=win,xmax=len(df_batter_og),color=colour_palette[4],linestyle='dotted',alpha=0.5,zorder=1)
+        ax.hlines(y=df_2023_output['xslgcon'].quantile(0.1),xmin=win,xmax=len(df_batter_og),color=colour_palette[5],linestyle='dotted',alpha=0.5,zorder=1)
+
+        hard_hit_text = ['90th %','75th %','25th %','10th %']
+        for i, x in enumerate(hard_hit_dates):
+                ax.text(min(win+win/50,win+win+5), x ,hard_hit_text[i], rotation=0,va='center', ha='left',
+                         bbox=dict(facecolor='white',alpha=0.7, edgecolor=colour_palette[2+i], pad=2),zorder=11)
+
+        # # Annotate with an arrow
+        # ax.annotate('June 6, 2023\nSeason Worst Decision Value', xy=(976, df_will.y_pred.rolling(window=win).mean().min()*100-0.03),
+        #              xytext=(976 - 150, df_will.y_pred.rolling(window=win).mean().min()*100 - 0.2),
+        #              arrowprops=dict(facecolor=colour_palette[7], shrink=0.01),zorder=150,fontsize=10,
+        #         bbox=dict(facecolor='white', edgecolor='black'),va='top')
+
+        ax.set_xlim(win,len(df_batter_og))
+        # ax.set_ylim(0.2,max(1,))
+
+        ax.set_yticks([0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1])
+
+        ax.set_xlabel('Balls In Play')
+        ax.set_ylabel('Expected Total Bases per Ball In Play (xSLGCON)')
+
+        from matplotlib.ticker import FormatStrFormatter
+
+        ax.yaxis.set_major_formatter(FormatStrFormatter('%.3f'))
+
+        axheader.text(s=f'{batter_select_name} - MLB - {win} Rolling BIP Expected Slugging on Contact (xSLGCON)',x=0.5,y=-0.5,ha='center',va='bottom',fontsize=14)
+        axfooter1.text(.05, 0.2, "By: Thomas Nestico",ha='left', va='bottom',fontsize=12)
+        axfooter1.text(0.95, 0.2, "Data: MLB",ha='right', va='bottom',fontsize=12)
+
+        fig.subplots_adjust(left=0.01, right=0.99, top=0.98, bottom=0.02)
+
+damage = App(ui.page_fluid(
+    ui.tags.base(href=base_url), 
+    ui.tags.div(
+         {"style": "width:95%;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.navset_tab(
+        ui.nav_control(
+             ui.a(
+                "Home",
+                href="home/"
+            ),
+        ),
+        ui.nav_menu(
+            "Batter Charts",
+            ui.nav_control(
+             ui.a(
+                "Spray",
+                href="spray/"
+            ),
+            ui.a(
+                "Decision Value",
+                href="decision_value/"
+            ),
+            ui.a(
+                "Damage Model",
+                href="damage_model/"
+            ),
+            ui.a(
+                "Batter Scatter",
+                href="batter_scatter/"
+            ),
+            ui.a(
+                "EV vs LA Plot",
+                href="ev_angle/"
+            )
+        ),
+        ),
+        ui.nav_menu(
+            "Goalie Charts",
+            ui.nav_control(
+             ui.a(
+                "GSAx Timeline",
+                href="gsax-timeline/"
+            ),
+             ui.a(
+                "GSAx Leaderboard",
+                href="gsax-leaderboard/"
+            ),
+             ui.a(
+                "GSAx Comparison",
+                href="gsax-comparison/"
+            )
+        ),
+        ),ui.nav_menu(
+            "Team Charts",
+            ui.nav_control(
+             ui.a(
+                "Team xG Rates",
+                href="team-xg-rates/"
+            ),
+        ),
+        ),ui.nav_control(
+             ui.a(
+                "Games",
+                href="games/"
+            ),
+        ),ui.nav_control(
+             ui.a(
+                "About",
+                href="about/"
+            ),
+        ),ui.nav_control(
+             ui.a(
+                "Articles",
+                href="articles/"
+            ),
+        )),ui.row(
+    ui.layout_sidebar(
+        
+ ui.panel_sidebar(
+                ui.input_select("batter_id",
+                                "Select Batter",
+                                 batter_dict,
+                                 width=1,
+                                 size=1,
+                                 selectize=True),
+                ui.input_numeric("quant",
+                                 "Select Percentile",
+                                 value=50,
+                                 min=0,max=100),
+                ui.input_numeric("rolling_window",
+                                 "Select Rolling Window",
+                                 value=50,
+                                 min=1)),
+
+   ui.panel_main(     
+        ui.navset_tab(
+
+            ui.nav("Damage Hex",
+                   ui.output_plot('hex_plot',
+                                  width='1200px',
+                                  height='1200px')),
+            ui.nav("Damage Roll",
+                   ui.output_plot('roll_plot',
+                                  width='1200px',
+                                  height='1200px'))
+        ))
+    )),)),server)

decision_value.py

@@ -0,0 +1,683 @@
+from shiny import App, Inputs, Outputs, Session, reactive, render, req, ui
+import datasets
+from datasets import load_dataset
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import numpy as np
+from scipy.stats import gaussian_kde
+import matplotlib
+from matplotlib.ticker import MaxNLocator
+from matplotlib.gridspec import GridSpec
+from scipy.stats import zscore
+import math
+import matplotlib
+from adjustText import adjust_text
+import matplotlib.ticker as mtick
+from shinywidgets import output_widget, render_widget
+import pandas as pd
+from configure import base_url
+import shinyswatch
+
+### Import Datasets
+dataset = load_dataset('nesticot/mlb_data', data_files=['mlb_pitch_data_2023.csv' ])
+dataset_train = dataset['train']
+df_2023_mlb = dataset_train.to_pandas().set_index(list(dataset_train.features.keys())[0]).reset_index(drop=True)
+
+### Import Datasets
+dataset = load_dataset('nesticot/mlb_data', data_files=['aaa_pitch_data_2023.csv' ])
+dataset_train = dataset['train']
+df_2023_aaa = dataset_train.to_pandas().set_index(list(dataset_train.features.keys())[0]).reset_index(drop=True)
+
+df_2023_mlb['level'] = 'MLB'
+df_2023_aaa['level'] = 'AAA'
+
+df_2023 = pd.concat([df_2023_mlb,df_2023_aaa])
+
+#print(df_2023)
+### Normalize Hit Locations
+import joblib
+swing_model =  joblib.load('swing.joblib')
+
+no_swing_model =  joblib.load('no_swing.joblib')
+
+# Now you can use the loaded model for prediction or any other task
+
+
+batter_dict = df_2023.sort_values('batter_name').set_index('batter_id')['batter_name'].to_dict()
+
+## Make Predictions
+## Define Features and Target
+features = ['px','pz','strikes','balls']
+## Set up 2023 Data for Prediction of Run Expectancy
+df_model_2023_no_swing = df_2023[df_2023.is_swing != 1].dropna(subset=features)
+df_model_2023_swing = df_2023[df_2023.is_swing == 1].dropna(subset=features)
+
+
+import xgboost as xgb
+df_model_2023_no_swing['y_pred'] = no_swing_model.predict(xgb.DMatrix(df_model_2023_no_swing[features]))
+df_model_2023_swing['y_pred'] = swing_model.predict(xgb.DMatrix(df_model_2023_swing[features]))
+
+df_model_2023 = pd.concat([df_model_2023_no_swing,df_model_2023_swing])
+import joblib
+# # Dump the model to a file named 'model.joblib'
+# model = joblib.load('xtb_model.joblib')
+
+# ## Create a Dataset to calculate xRV/100 Pitches
+# df_model_2023['pitcher_name'] = df_model_2023.pitcher.map(pitcher_dict)
+# df_model_2023['player_team'] = df_model_2023.batter.map(team_player_dict)
+df_model_2023_group = df_model_2023.groupby(['batter_id','batter_name','level']).agg(
+    pitches = ('start_speed','count'),
+    y_pred =  ('y_pred','mean'),
+    )
+
+## Minimum 500 pitches faced
+#min_pitches = 300
+#df_model_2023_group = df_model_2023_group[df_model_2023_group.pitches >= min_pitches]
+## Calculate 20-80 Scale
+df_model_2023_group['decision_value'] = zscore(df_model_2023_group['y_pred'])
+df_model_2023_group['decision_value'] = (50+df_model_2023_group['decision_value']*10)
+
+## Create a Dataset to calculate xRV/100 for Pitches Taken
+df_model_2023_group_no_swing = df_model_2023[df_model_2023.is_swing!=1].groupby(['batter_id','batter_name','level']).agg(
+    pitches = ('start_speed','count'),
+    y_pred =  ('y_pred','mean')
+    )
+
+# Select Pitches with 500 total pitches
+df_model_2023_group_no_swing = df_model_2023_group_no_swing[df_model_2023_group_no_swing.index.get_level_values(1).isin(df_model_2023_group.index.get_level_values(1))]
+## Calculate 20-80 Scale
+df_model_2023_group_no_swing['iz_awareness'] = zscore(df_model_2023_group_no_swing['y_pred'])
+df_model_2023_group_no_swing['iz_awareness'] = (((50+df_model_2023_group_no_swing['iz_awareness']*10)))
+
+## Create a Dataset for xRV/100 Pitches Swung At
+df_model_2023_group_swing = df_model_2023[df_model_2023.is_swing==1].groupby(['batter_id','batter_name','level']).agg(
+    pitches = ('start_speed','count'),
+    y_pred =  ('y_pred','mean')
+    )
+
+# Select Pitches with 500 total pitches
+df_model_2023_group_swing = df_model_2023_group_swing[df_model_2023_group_swing.index.get_level_values(1).isin(df_model_2023_group.index.get_level_values(1))]
+## Calculate 20-80 Scale
+df_model_2023_group_swing['oz_awareness'] = zscore(df_model_2023_group_swing['y_pred'])
+df_model_2023_group_swing['oz_awareness'] = (((50+df_model_2023_group_swing['oz_awareness']*10)))
+
+## Create df for plotting
+# Merge Datasets
+df_model_2023_group_swing_plus_no = df_model_2023_group_swing.merge(df_model_2023_group_no_swing,left_index=True,right_index=True,suffixes=['_swing','_no_swing'])
+df_model_2023_group_swing_plus_no['pitches'] = df_model_2023_group_swing_plus_no.pitches_swing + df_model_2023_group_swing_plus_no.pitches_no_swing
+
+# Calculate xRV/100 Pitches
+df_model_2023_group_swing_plus_no['y_pred'] = (df_model_2023_group_swing_plus_no.y_pred_swing*df_model_2023_group_swing_plus_no.pitches_swing + \
+                                              df_model_2023_group_swing_plus_no.y_pred_no_swing*df_model_2023_group_swing_plus_no.pitches_no_swing) / \
+                                              df_model_2023_group_swing_plus_no.pitches
+
+df_model_2023_group_swing_plus_no = df_model_2023_group_swing_plus_no.merge(right=df_model_2023_group,
+                                                                            left_index=True,
+                                                                            right_index=True,
+                                                                            suffixes=['','_y'])
+
+df_model_2023_group_swing_plus_no = df_model_2023_group_swing_plus_no.reset_index()
+team_dict = df_2023.groupby(['batter_name'])[['batter_id','batter_team']].tail().set_index('batter_id')['batter_team'].to_dict()
+df_model_2023_group_swing_plus_no['team'] = df_model_2023_group_swing_plus_no['batter_id'].map(team_dict)
+df_model_2023_group_swing_plus_no = df_model_2023_group_swing_plus_no.set_index(['batter_id','batter_name','level','team'])
+
+df_model_2023_group_swing_plus_no = df_model_2023_group_swing_plus_no[df_model_2023_group_swing_plus_no['pitches']>=250]
+df_model_2023_group_swing_plus_no_copy = df_model_2023_group_swing_plus_no.copy()
+import matplotlib
+
+colour_palette = ['#FFB000','#648FFF','#785EF0',
+                  '#DC267F','#FE6100','#3D1EB2','#894D80','#16AA02','#B5592B','#A3C1ED']
+
+cmap_hue = matplotlib.colors.LinearSegmentedColormap.from_list("", [colour_palette[1],'#ffffff',colour_palette[0]])
+cmap_hue2 = matplotlib.colors.LinearSegmentedColormap.from_list("",['#ffffff',colour_palette[0]])
+
+
+from matplotlib.pyplot import text
+import inflect
+from scipy.stats import percentileofscore
+p = inflect.engine()
+
+
+
+
+def server(input,output,session):
+
+    @output
+    @render.plot(alt="hex_plot")
+    def scatter_plot():
+
+        if input.batter_id() is "":
+            fig = plt.figure(figsize=(12, 12))
+            fig.text(s='Please Select a Batter',x=0.5,y=0.5)
+            return
+        print(df_model_2023_group_swing_plus_no_copy)
+        print(input.level_list())
+        df_model_2023_group_swing_plus_no = df_model_2023_group_swing_plus_no_copy[df_model_2023_group_swing_plus_no_copy.index.get_level_values(2) == input.level_list()]
+        print('this one')
+        print(df_model_2023_group_swing_plus_no)
+        batter_select_id = int(input.batter_id())
+        # batter_select_name = 'Edouard Julien'
+        #max(1,int(input.pitch_min()))
+        plot_min =  max(250,int(input.pitch_min()))
+        df_model_2023_group_swing_plus_no = df_model_2023_group_swing_plus_no[df_model_2023_group_swing_plus_no.pitches >= plot_min]
+        ## Plot In-Zone vs Out-of-Zone Awareness
+        sns.set_theme(style="whitegrid", palette="pastel")
+        # fig, ax = plt.subplots(1,1,figsize=(12,12))
+        fig = plt.figure(figsize=(12,12))
+        gs = GridSpec(3, 3, height_ratios=[0.6,10,0.2], width_ratios=[0.25,0.50,0.25])
+
+        axheader = fig.add_subplot(gs[0, :])
+        #ax10 = fig.add_subplot(gs[1, 0])
+        ax = fig.add_subplot(gs[1, :])  # Subplot at the top-right position
+        #ax12 = fig.add_subplot(gs[1, 2])
+        axfooter1 = fig.add_subplot(gs[-1, 0])
+        axfooter2 = fig.add_subplot(gs[-1, 1])
+        axfooter3 = fig.add_subplot(gs[-1, 2])
+
+        cmap_hue = matplotlib.colors.LinearSegmentedColormap.from_list("", [colour_palette[1],colour_palette[3],colour_palette[0]])
+        norm = plt.Normalize(df_model_2023_group_swing_plus_no['y_pred'].min()*100, df_model_2023_group_swing_plus_no['y_pred'].max()*100)
+
+        sns.scatterplot(
+                        x=df_model_2023_group_swing_plus_no['y_pred_swing']*100,
+                        y=df_model_2023_group_swing_plus_no['y_pred_no_swing']*100,
+                        hue=df_model_2023_group_swing_plus_no['y_pred']*100,
+                        size=df_model_2023_group_swing_plus_no['pitches_swing']/df_model_2023_group_swing_plus_no['pitches'],
+                        palette=cmap_hue,ax=ax)
+
+        sm = plt.cm.ScalarMappable(cmap=cmap_hue, norm=norm)
+        cbar  = plt.colorbar(sm, cax=axfooter2, orientation='horizontal',shrink=1)
+        cbar.set_label('Decision Value xRV/100 Pitches',fontsize=12)
+
+        ax.hlines(xmin=(math.floor((df_model_2023_group_swing_plus_no['y_pred_swing'].min()*100*100-0.01)/5))*5/100,
+                xmax= (math.ceil((df_model_2023_group_swing_plus_no['y_pred_swing'].max()**100100+0.01)/5))*5/100,
+                y=df_model_2023_group_swing_plus_no['y_pred_no_swing'].mean()*100,color='gray',linewidth=3,linestyle='dotted',alpha=0.4)
+
+        ax.vlines(ymin=(math.floor((df_model_2023_group_swing_plus_no['y_pred_no_swing'].min()*100*100-0.01)/5))*5/100,
+                ymax= (math.ceil((df_model_2023_group_swing_plus_no['y_pred_no_swing'].max()*100*100+0.01)/5))*5/100,
+                x=df_model_2023_group_swing_plus_no['y_pred_swing'].mean()*100,color='gray',linewidth=3,linestyle='dotted',alpha=0.4)
+
+        x_lim_min = (math.floor((df_model_2023_group_swing_plus_no['y_pred_swing'].min()*100*100)/5))*5/100
+        x_lim_max = (math.ceil((df_model_2023_group_swing_plus_no['y_pred_swing'].max()*100*100)/5))*5/100
+
+        y_lim_min = (math.floor((df_model_2023_group_swing_plus_no['y_pred_no_swing'].min()*100*100)/5))*5/100
+        y_lim_max = (math.ceil((df_model_2023_group_swing_plus_no['y_pred_no_swing'].max()*100*100)/5))*5/100
+
+        ax.set_xlim(x_lim_min,x_lim_max)
+        ax.set_ylim(y_lim_min,y_lim_max)
+
+        ax.tick_params(axis='both', which='major', labelsize=12)
+
+        ax.set_xlabel('Out-of-Zone Awareness Value xRV/100 Swings',fontsize=16)
+        ax.set_ylabel('In-Zone Awareness Value xRV/100 Takes',fontsize=16)
+        ax.get_legend().remove()
+
+
+        ts=[]
+
+
+        # thresh = 0.5
+        # thresh_2 = -0.9
+        # for i in range(len(df_model_2023_group_swing_plus_no)):
+        #         if (df_model_2023_group_swing_plus_no['y_pred'].values[i]*100) >= thresh or \
+        #         (df_model_2023_group_swing_plus_no['y_pred'].values[i]*100) <= thresh_2 or \
+        #                (str(df_model_2023_group_swing_plus_no.index.get_level_values(0).values[i]) in (input.name_list())) :
+        #                 ts.append(ax.text(x=df_model_2023_group_swing_plus_no['y_pred_swing'].values[i]*100,
+        #                                 y=df_model_2023_group_swing_plus_no['y_pred_no_swing'].values[i]*100,
+        #                                 s=df_model_2023_group_swing_plus_no.index.get_level_values(1).values[i],
+        #                                 fontsize=8))
+        thresh = 0.5
+        thresh_2 = -0.9
+        for i in range(len(df_model_2023_group_swing_plus_no)):
+                if (df_model_2023_group_swing_plus_no['y_pred_swing'].values[i]) >= df_model_2023_group_swing_plus_no['y_pred_swing'].quantile(0.98) or \
+                (df_model_2023_group_swing_plus_no['y_pred_swing'].values[i])  <= df_model_2023_group_swing_plus_no['y_pred_swing'].quantile(0.02) or \
+                (df_model_2023_group_swing_plus_no['y_pred_no_swing'].values[i]) >= df_model_2023_group_swing_plus_no['y_pred_no_swing'].quantile(0.98) or \
+                (df_model_2023_group_swing_plus_no['y_pred_no_swing'].values[i])  <= df_model_2023_group_swing_plus_no['y_pred_no_swing'].quantile(0.02) or \
+                (df_model_2023_group_swing_plus_no['y_pred'].values[i]) >= df_model_2023_group_swing_plus_no['y_pred'].quantile(0.98) or \
+                (df_model_2023_group_swing_plus_no['y_pred'].values[i])  <= df_model_2023_group_swing_plus_no['y_pred'].quantile(0.02) or \
+                       (str(df_model_2023_group_swing_plus_no.index.get_level_values(0).values[i]) in (input.name_list())) :
+                        ts.append(ax.text(x=df_model_2023_group_swing_plus_no['y_pred_swing'].values[i]*100,
+                                        y=df_model_2023_group_swing_plus_no['y_pred_no_swing'].values[i]*100,
+                                        s=df_model_2023_group_swing_plus_no.index.get_level_values(1).values[i],
+                                        fontsize=8))
+
+        ax.text(x=x_lim_min+abs(x_lim_min)*0.02,y=y_lim_max-abs(y_lim_max-y_lim_min)*0.02,s=f'Min. {plot_min} Pitches',fontsize='10',fontstyle='oblique',va='top',
+                bbox=dict(facecolor='white', edgecolor='black'))
+        # ax.text(x=x_lim_min+abs(x_lim_min)*0.02,y=y_lim_max-abs(y_lim_max-y_lim_min)*0.06,s=f'Labels for Batters with\nDescion Value xRV/100 > {thresh:.2f}\nDescion Value xRV/100 < {thresh_2:.2f}',fontsize='10',fontstyle='oblique',va='top',
+        #         bbox=dict(facecolor='white', edgecolor='black'))
+        ax.text(x=x_lim_min+abs(x_lim_min)*0.02,y=y_lim_max-abs(y_lim_max-y_lim_min)*0.06,s=f'Point Size Represents Swing%',fontsize='10',fontstyle='oblique',va='top',
+                bbox=dict(facecolor='white', edgecolor='black'))
+
+        adjust_text(ts,
+                arrowprops=dict(arrowstyle="-", color=colour_palette[4], lw=1),ax=ax)
+     
+        axfooter1.axis('off')
+        axfooter3.axis('off')
+        axheader.axis('off')
+
+        axheader.text(s=f'{input.level_list()} In-Zone vs Out-of-Zone Awareness Value',fontsize=24,x=0.5,y=0,va='top',ha='center')
+
+        axfooter1.text(0.05, -0.5,"By: Thomas Nestico\n      @TJStats",ha='left', va='bottom',fontsize=12)
+        axfooter3.text(0.95, -0.5, "Data: MLB",ha='right', va='bottom',fontsize=12)   
+        fig.subplots_adjust(left=0.01, right=0.99, top=0.975, bottom=0.025)
+
+    @output
+    @render.plot(alt="hex_plot")
+    def dv_plot():
+
+        if input.batter_id() is "":
+            fig = plt.figure(figsize=(12, 12))
+            fig.text(s='Please Select a Batter',x=0.5,y=0.5)
+            return
+        
+        player_select = int(input.batter_id())
+        player_select_full = batter_dict[player_select]
+
+
+        df_will = df_model_2023[df_model_2023.batter_id == player_select].sort_values(by=['game_date','start_time'])
+        df_will = df_will[df_will['level']==input.level_list()]
+        # df_will['y_pred'] = df_will['y_pred'] - df_will['y_pred'].mean()
+
+        win = max(1,int(input.rolling_window()))
+        sns.set_theme(style="whitegrid", palette="pastel")
+        #fig, ax = plt.subplots(1, 1, figsize=(10, 10),dpi=300)
+
+        from matplotlib.gridspec import GridSpec
+        # fig,ax = plt.subplots(figsize=(12, 12),dpi=150)
+        fig = plt.figure(figsize=(12,12))
+        gs = GridSpec(3, 3, height_ratios=[0.3,10,0.2], width_ratios=[0.01,2,0.01])
+
+        axheader = fig.add_subplot(gs[0, :])
+        ax10 = fig.add_subplot(gs[1, 0])
+        ax = fig.add_subplot(gs[1, 1])  # Subplot at the top-right position
+        ax12 = fig.add_subplot(gs[1, 2])
+        axfooter1 = fig.add_subplot(gs[-1, :])
+
+        axheader.axis('off')
+        ax10.axis('off')
+        ax12.axis('off')
+        axfooter1.axis('off')
+
+
+        sns.lineplot( x= range(win,len(df_will.y_pred.rolling(window=win).mean())+1),
+                y= df_will.y_pred.rolling(window=win).mean().dropna()*100,
+                color=colour_palette[0],linewidth=2,ax=ax,zorder=100)
+
+        ax.hlines(y=df_will.y_pred.mean()*100,xmin=win,xmax=len(df_will),color=colour_palette[0],linestyle='--',
+                label=f'{player_select_full} Average: {df_will.y_pred.mean()*100:.2} xRV/100 ({p.ordinal(int(np.around(percentileofscore(df_model_2023_group_swing_plus_no.y_pred,df_will.y_pred.mean(), kind="strict"))))} Percentile)')
+
+        # ax.hlines(y=df_model_2023.y_pred.std()*100,xmin=win,xmax=len(df_will))
+
+        # sns.scatterplot( x= [976],
+        #               y= df_will.y_pred.rolling(window=win).mean().min()*100,
+        #               color=colour_palette[0],linewidth=2,ax=ax,zorder=100,s=100,edgecolor=colour_palette[7])
+
+
+        ax.hlines(y=df_model_2023_group_swing_plus_no.y_pred.mean()*100,xmin=win,xmax=len(df_will),color=colour_palette[1],linestyle='-.',alpha=1,
+                label = f'{input.level_list()} Average: {df_model_2023_group_swing_plus_no.y_pred.mean()*100:.2f} xRV/100')
+
+        ax.legend()
+
+        hard_hit_dates = [df_model_2023_group_swing_plus_no.y_pred.quantile(0.9)*100,
+                        df_model_2023_group_swing_plus_no.y_pred.quantile(0.75)*100,
+                        df_model_2023_group_swing_plus_no.y_pred.quantile(0.25)*100,
+                        df_model_2023_group_swing_plus_no.y_pred.quantile(0.1)*100]
+
+
+
+        ax.hlines(y=df_model_2023_group_swing_plus_no.y_pred.quantile(0.9)*100,xmin=win,xmax=len(df_will),color=colour_palette[2],linestyle='dotted',alpha=0.5,zorder=1)
+        ax.hlines(y=df_model_2023_group_swing_plus_no.y_pred.quantile(0.75)*100,xmin=win,xmax=len(df_will),color=colour_palette[3],linestyle='dotted',alpha=0.5,zorder=1)
+        ax.hlines(y=df_model_2023_group_swing_plus_no.y_pred.quantile(0.25)*100,xmin=win,xmax=len(df_will),color=colour_palette[4],linestyle='dotted',alpha=0.5,zorder=1)
+        ax.hlines(y=df_model_2023_group_swing_plus_no.y_pred.quantile(0.1)*100,xmin=win,xmax=len(df_will),color=colour_palette[5],linestyle='dotted',alpha=0.5,zorder=1)
+
+        hard_hit_text = ['90th %','75th %','25th %','10th %']
+        for i, x in enumerate(hard_hit_dates):
+                ax.text(min(win+win/1000,win+win+5), x ,hard_hit_text[i], rotation=0,va='center', ha='left',
+                        bbox=dict(facecolor='white',alpha=0.7, edgecolor=colour_palette[2+i], pad=2),zorder=11)
+
+        # # Annotate with an arrow
+        # ax.annotate('June 6, 2023\nSeason Worst Decision Value', xy=(976, df_will.y_pred.rolling(window=win).mean().min()*100-0.03),
+        #              xytext=(976 - 150, df_will.y_pred.rolling(window=win).mean().min()*100 - 0.2),
+        #              arrowprops=dict(facecolor=colour_palette[7], shrink=0.01),zorder=150,fontsize=10,
+        #         bbox=dict(facecolor='white', edgecolor='black'),va='top')
+
+        ax.set_xlim(win,len(df_will))
+        #ax.set_ylim(-1.5,1.5)
+        ax.set_yticks([-1.5,-1,-0.5,0,0.5,1,1.5])
+        ax.set_xlabel('Pitch')
+        ax.set_ylabel('Expected Run Value Added per 100 Pitches (xRV/100)')
+
+        axheader.text(s=f'{player_select_full} - {input.level_list()} - {win} Pitch Rolling Swing Decision Expected Run Value Added',x=0.5,y=-0.5,ha='center',va='bottom',fontsize=14)
+        axfooter1.text(.05, 0.2, "By: Thomas Nestico",ha='left', va='bottom',fontsize=12)
+        axfooter1.text(0.95, 0.2, "Data: MLB",ha='right', va='bottom',fontsize=12)
+
+        fig.subplots_adjust(left=0.01, right=0.99, top=0.98, bottom=0.02)
+        #fig.set_facecolor(colour_palette[5])
+
+    @output
+    @render.plot(alt="hex_plot")
+    def iz_plot():
+          
+        if input.batter_id() is "":
+            fig = plt.figure(figsize=(12, 12))
+            fig.text(s='Please Select a Batter',x=0.5,y=0.5)
+            return
+        
+        player_select = int(input.batter_id())
+        player_select_full = batter_dict[player_select]
+
+
+        df_will = df_model_2023[df_model_2023.batter_id == player_select].sort_values(by=['game_date','start_time'])
+        df_will = df_will[df_will['level']==input.level_list()]
+        df_will = df_will[df_will['is_swing'] != 1]
+        
+        win = max(1,int(input.rolling_window()))
+        sns.set_theme(style="whitegrid", palette="pastel")
+        #fig, ax = plt.subplots(1, 1, figsize=(10, 10),dpi=300)
+
+        from matplotlib.gridspec import GridSpec
+        # fig,ax = plt.subplots(figsize=(12, 12),dpi=150)
+        fig = plt.figure(figsize=(12,12))
+        gs = GridSpec(3, 3, height_ratios=[0.3,10,0.2], width_ratios=[0.01,2,0.01])
+
+        axheader = fig.add_subplot(gs[0, :])
+        ax10 = fig.add_subplot(gs[1, 0])
+        ax = fig.add_subplot(gs[1, 1])  # Subplot at the top-right position
+        ax12 = fig.add_subplot(gs[1, 2])
+        axfooter1 = fig.add_subplot(gs[-1, :])
+
+        axheader.axis('off')
+        ax10.axis('off')
+        ax12.axis('off')
+        axfooter1.axis('off')
+
+
+        sns.lineplot( x= range(win,len(df_will.y_pred.rolling(window=win).mean())+1),
+                y= df_will.y_pred.rolling(window=win).mean().dropna()*100,
+                color=colour_palette[0],linewidth=2,ax=ax,zorder=100)
+
+        ax.hlines(y=df_will.y_pred.mean()*100,xmin=win,xmax=len(df_will),color=colour_palette[0],linestyle='--',
+                label=f'{player_select_full} Average: {df_will.y_pred.mean()*100:.2} xRV/100 ({p.ordinal(int(np.around(percentileofscore(df_model_2023_group_swing_plus_no.y_pred_no_swing,df_will.y_pred.mean(), kind="strict"))))} Percentile)')
+
+        # ax.hlines(y=df_model_2023.y_pred_no_swing.std()*100,xmin=win,xmax=len(df_will))
+
+        # sns.scatterplot( x= [976],
+        #               y= df_will.y_pred.rolling(window=win).mean().min()*100,
+        #               color=colour_palette[0],linewidth=2,ax=ax,zorder=100,s=100,edgecolor=colour_palette[7])
+
+
+        ax.hlines(y=df_model_2023_group_swing_plus_no.y_pred_no_swing.mean()*100,xmin=win,xmax=len(df_will),color=colour_palette[1],linestyle='-.',alpha=1,
+                label = f'{input.level_list()} Average: {df_model_2023_group_swing_plus_no.y_pred_no_swing.mean()*100:.2} xRV/100')
+
+        ax.legend()
+
+        hard_hit_dates = [df_model_2023_group_swing_plus_no.y_pred_no_swing.quantile(0.9)*100,
+                        df_model_2023_group_swing_plus_no.y_pred_no_swing.quantile(0.75)*100,
+                        df_model_2023_group_swing_plus_no.y_pred_no_swing.quantile(0.25)*100,
+                        df_model_2023_group_swing_plus_no.y_pred_no_swing.quantile(0.1)*100]
+
+
+
+        ax.hlines(y=df_model_2023_group_swing_plus_no.y_pred_no_swing.quantile(0.9)*100,xmin=win,xmax=len(df_will),color=colour_palette[2],linestyle='dotted',alpha=0.5,zorder=1)
+        ax.hlines(y=df_model_2023_group_swing_plus_no.y_pred_no_swing.quantile(0.75)*100,xmin=win,xmax=len(df_will),color=colour_palette[3],linestyle='dotted',alpha=0.5,zorder=1)
+        ax.hlines(y=df_model_2023_group_swing_plus_no.y_pred_no_swing.quantile(0.25)*100,xmin=win,xmax=len(df_will),color=colour_palette[4],linestyle='dotted',alpha=0.5,zorder=1)
+        ax.hlines(y=df_model_2023_group_swing_plus_no.y_pred_no_swing.quantile(0.1)*100,xmin=win,xmax=len(df_will),color=colour_palette[5],linestyle='dotted',alpha=0.5,zorder=1)
+
+        hard_hit_text = ['90th %','75th %','25th %','10th %']
+        for i, x in enumerate(hard_hit_dates):
+                ax.text(min(win+win/1000,win+win+5), x ,hard_hit_text[i], rotation=0,va='center', ha='left',
+                        bbox=dict(facecolor='white',alpha=0.7, edgecolor=colour_palette[2+i], pad=2),zorder=11)
+
+        # # Annotate with an arrow
+        # ax.annotate('June 6, 2023\nSeason Worst Decision Value', xy=(976, df_will.y_pred.rolling(window=win).mean().min()*100-0.03),
+        #              xytext=(976 - 150, df_will.y_pred.rolling(window=win).mean().min()*100 - 0.2),
+        #              arrowprops=dict(facecolor=colour_palette[7], shrink=0.01),zorder=150,fontsize=10,
+        #         bbox=dict(facecolor='white', edgecolor='black'),va='top')
+
+        ax.set_xlim(win,len(df_will))
+        ax.set_yticks([1.0,1.5,2.0,2.5,3.0])
+        # ax.set_ylim(1,3)
+
+        ax.set_xlabel('Takes')
+        ax.set_ylabel('Expected Run Value Added per 100 Pitches (xRV/100)')
+
+        axheader.text(s=f'{player_select_full} - {input.level_list()} - {win} Pitch Rolling In-Zone Awareness Expected Run Value Added',x=0.5,y=-0.5,ha='center',va='bottom',fontsize=14)
+        axfooter1.text(.05, 0.2, "By: Thomas Nestico",ha='left', va='bottom',fontsize=12)
+        axfooter1.text(0.95, 0.2, "Data: MLB",ha='right', va='bottom',fontsize=12)
+
+        fig.subplots_adjust(left=0.01, right=0.99, top=0.98, bottom=0.02)
+
+    @output
+    @render.plot(alt="hex_plot")
+    def oz_plot():
+        if input.batter_id() is "":
+            fig = plt.figure(figsize=(12, 12))
+            fig.text(s='Please Select a Batter',x=0.5,y=0.5)
+            return
+        
+        player_select = int(input.batter_id())
+        player_select_full = batter_dict[player_select]
+
+
+
+        df_will = df_model_2023[df_model_2023.batter_id == player_select].sort_values(by=['game_date','start_time'])
+        df_will = df_will[df_will['level']==input.level_list()]
+        df_will = df_will[df_will['is_swing'] == 1]
+
+        win = max(1,int(input.rolling_window()))
+        sns.set_theme(style="whitegrid", palette="pastel")
+        #fig, ax = plt.subplots(1, 1, figsize=(10, 10),dpi=300)
+
+        from matplotlib.gridspec import GridSpec
+        # fig,ax = plt.subplots(figsize=(12, 12),dpi=150)
+        fig = plt.figure(figsize=(12,12))
+        gs = GridSpec(3, 3, height_ratios=[0.3,10,0.2], width_ratios=[0.01,2,0.01])
+
+        axheader = fig.add_subplot(gs[0, :])
+        ax10 = fig.add_subplot(gs[1, 0])
+        ax = fig.add_subplot(gs[1, 1])  # Subplot at the top-right position
+        ax12 = fig.add_subplot(gs[1, 2])
+        axfooter1 = fig.add_subplot(gs[-1, :])
+
+        axheader.axis('off')
+        ax10.axis('off')
+        ax12.axis('off')
+        axfooter1.axis('off')
+
+
+        sns.lineplot( x= range(win,len(df_will.y_pred.rolling(window=win).mean())+1),
+                y= df_will.y_pred.rolling(window=win).mean().dropna()*100,
+                color=colour_palette[0],linewidth=2,ax=ax,zorder=100)
+
+        ax.hlines(y=df_will.y_pred.mean()*100,xmin=win,xmax=len(df_will),color=colour_palette[0],linestyle='--',
+                label=f'{player_select_full} Average: {df_will.y_pred.mean()*100:.2} xRV/100 ({p.ordinal(int(np.around(percentileofscore(df_model_2023_group_swing_plus_no.y_pred_swing,df_will.y_pred.mean(), kind="strict"))))} Percentile)')
+
+        # ax.hlines(y=df_model_2023.y_pred_swing.std()*100,xmin=win,xmax=len(df_will))
+
+        # sns.scatterplot( x= [976],
+        #               y= df_will.y_pred.rolling(window=win).mean().min()*100,
+        #               color=colour_palette[0],linewidth=2,ax=ax,zorder=100,s=100,edgecolor=colour_palette[7])
+
+
+        ax.hlines(y=df_model_2023_group_swing_plus_no.y_pred_swing.mean()*100,xmin=win,xmax=len(df_will),color=colour_palette[1],linestyle='-.',alpha=1,
+                label = f'{input.level_list()} Average: {df_model_2023_group_swing_plus_no.y_pred_swing.mean()*100:.2} xRV/100')
+
+        ax.legend()
+
+        hard_hit_dates = [df_model_2023_group_swing_plus_no.y_pred_swing.quantile(0.9)*100,
+                        df_model_2023_group_swing_plus_no.y_pred_swing.quantile(0.75)*100,
+                        df_model_2023_group_swing_plus_no.y_pred_swing.quantile(0.25)*100,
+                        df_model_2023_group_swing_plus_no.y_pred_swing.quantile(0.1)*100]
+
+
+
+        ax.hlines(y=df_model_2023_group_swing_plus_no.y_pred_swing.quantile(0.9)*100,xmin=win,xmax=len(df_will),color=colour_palette[2],linestyle='dotted',alpha=0.5,zorder=1)
+        ax.hlines(y=df_model_2023_group_swing_plus_no.y_pred_swing.quantile(0.75)*100,xmin=win,xmax=len(df_will),color=colour_palette[3],linestyle='dotted',alpha=0.5,zorder=1)
+        ax.hlines(y=df_model_2023_group_swing_plus_no.y_pred_swing.quantile(0.25)*100,xmin=win,xmax=len(df_will),color=colour_palette[4],linestyle='dotted',alpha=0.5,zorder=1)
+        ax.hlines(y=df_model_2023_group_swing_plus_no.y_pred_swing.quantile(0.1)*100,xmin=win,xmax=len(df_will),color=colour_palette[5],linestyle='dotted',alpha=0.5,zorder=1)
+
+        hard_hit_text = ['90th %','75th %','25th %','10th %']
+        for i, x in enumerate(hard_hit_dates):
+                ax.text(min(win+win/1000,win+win+5), x ,hard_hit_text[i], rotation=0,va='center', ha='left',
+                        bbox=dict(facecolor='white',alpha=0.7, edgecolor=colour_palette[2+i], pad=2),zorder=11)
+
+        # # Annotate with an arrow
+        # ax.annotate('June 6, 2023\nSeason Worst Decision Value', xy=(976, df_will.y_pred.rolling(window=win).mean().min()*100-0.03),
+        #              xytext=(976 - 150, df_will.y_pred.rolling(window=win).mean().min()*100 - 0.2),
+        #              arrowprops=dict(facecolor=colour_palette[7], shrink=0.01),zorder=150,fontsize=10,
+        #         bbox=dict(facecolor='white', edgecolor='black'),va='top')
+
+        ax.set_xlim(win,len(df_will))
+        #ax.set_ylim(-3.25,-1.25)
+        ax.set_yticks([-3.25,-2.75,-2.25,-1.75,-1.25])
+        ax.set_xlabel('Swing')
+        ax.set_ylabel('Expected Run Value Added per 100 Pitches (xRV/100)')
+
+        axheader.text(s=f'{player_select_full} - {input.level_list()} - {win} Pitch Rolling Out of Zone Awareness Expected Run Value Added',x=0.5,y=-0.5,ha='center',va='bottom',fontsize=14)
+        axfooter1.text(.05, 0.2, "By: Thomas Nestico",ha='left', va='bottom',fontsize=12)
+        axfooter1.text(0.95, 0.2, "Data: MLB",ha='right', va='bottom',fontsize=12)
+
+        fig.subplots_adjust(left=0.01, right=0.99, top=0.98, bottom=0.02)   
+
+decision_value = 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.navset_tab(
+        ui.nav_control(
+             ui.a(
+                "Home",
+                href="home/"
+            ),
+        ),
+        ui.nav_menu(
+            "Batter Charts",
+            ui.nav_control(
+             ui.a(
+                "Spray",
+                href="spray/"
+            ),
+            ui.a(
+                "Decision Value",
+                href="decision_value/"
+            ),
+            ui.a(
+                "Damage Model",
+                href="damage_model/"
+            ),
+            ui.a(
+                "Batter Scatter",
+                href="batter_scatter/"
+            ),
+            ui.a(
+                "EV vs LA Plot",
+                href="ev_angle/"
+            )
+        ),
+        ),
+        ui.nav_menu(
+            "Goalie Charts",
+            ui.nav_control(
+             ui.a(
+                "GSAx Timeline",
+                href="gsax-timeline/"
+            ),
+             ui.a(
+                "GSAx Leaderboard",
+                href="gsax-leaderboard/"
+            ),
+             ui.a(
+                "GSAx Comparison",
+                href="gsax-comparison/"
+            )
+        ),
+        ),ui.nav_menu(
+            "Team Charts",
+            ui.nav_control(
+             ui.a(
+                "Team xG Rates",
+                href="team-xg-rates/"
+            ),
+        ),
+        ),ui.nav_control(
+             ui.a(
+                "Games",
+                href="games/"
+            ),
+        ),ui.nav_control(
+             ui.a(
+                "About",
+                href="about/"
+            ),
+        ),ui.nav_control(
+             ui.a(
+                "Articles",
+                href="articles/"
+            ),
+        )),ui.row(
+    ui.layout_sidebar(
+        
+        ui.panel_sidebar(
+             
+                                 
+                ui.input_numeric("pitch_min",
+                                 "Select Pitch Minimum [min. 250] (Scatter)",
+                                 value=500,
+                                 min=250),                 
+
+                ui.input_select("name_list",
+                                 "Select Players to List (Scatter)",
+                                 batter_dict,
+                                 selectize=True,
+                                 multiple=True),
+                ui.input_select("batter_id",
+                                "Select Batter (Rolling)",
+                                 batter_dict,
+                                 width=1,
+                                 size=1,
+                                 selectize=True),
+                ui.input_numeric("rolling_window",
+                                 "Select Rolling Window (Rolling)",
+                                 value=100,
+                                 min=1),                
+
+                ui.input_select("level_list",
+                                 "Select Level",
+                                 ['MLB','AAA'],
+                                 selected='MLB')),
+
+   ui.panel_main(     
+        ui.navset_tab(
+
+            ui.nav("Scatter Plot",
+                   ui.output_plot('scatter_plot',
+                                  width='1000px',
+                                  height='1000px')),
+            ui.nav("Rolling DV",
+                   ui.output_plot('dv_plot',
+                                  width='1000px',
+                                  height='1000px')),
+            ui.nav("Rolling In-Zone",
+                   ui.output_plot('iz_plot',
+                                  width='1000px',
+                                  height='1000px')),
+            ui.nav("Rolling Out-of-Zone",
+                   ui.output_plot('oz_plot',
+                                  width='1000px',
+                                  height='1000px'))
+        ))
+    )),)),server)

ev_angle.py

@@ -0,0 +1,270 @@
+from shiny import App, Inputs, Outputs, Session, reactive, render, req, ui
+import datasets
+from datasets import load_dataset
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import numpy as np
+from scipy.stats import gaussian_kde
+import matplotlib
+from matplotlib.ticker import MaxNLocator
+from matplotlib.gridspec import GridSpec
+from scipy.stats import zscore
+import math
+import matplotlib
+from adjustText import adjust_text
+import matplotlib.ticker as mtick
+from shinywidgets import output_widget, render_widget
+import pandas as pd
+from configure import base_url
+import shinyswatch
+from matplotlib.pyplot import text
+
+
+### Import Datasets
+dataset = load_dataset('nesticot/mlb_data', data_files=['mlb_pitch_data_2023.csv' ])
+dataset_train = dataset['train']
+exit_velo_df = dataset_train.to_pandas().set_index(list(dataset_train.features.keys())[0]).reset_index(drop=True)
+
+colour_palette = ['#FFB000','#648FFF','#785EF0',
+                  '#DC267F','#FE6100','#3D1EB2','#894D80','#16AA02','#B5592B','#A3C1ED']
+
+
+#exit_velo_df = pd.read_csv('exit_velo_df.csv',index_col=[0])
+
+conditions = [
+    (exit_velo_df['launch_speed'].isna()),
+    (exit_velo_df['launch_speed']*1.5 - exit_velo_df['launch_angle'] >= 117 ) & (exit_velo_df['launch_speed'] + exit_velo_df['launch_angle'] >= 124) & (exit_velo_df['launch_speed'] > 98) & (exit_velo_df['launch_angle'] >= 8) & (exit_velo_df['launch_angle'] <= 50)
+]
+
+choices = [False,True]
+exit_velo_df['barrel'] = np.select(conditions, choices, default=np.nan)
+
+test_df = exit_velo_df.sort_values(by='batter_name').drop_duplicates(subset='batter_id').reset_index(drop=True)[['batter_id','batter_name']]#['pitcher'].to_dict()
+test_df = test_df.set_index('batter_id')
+
+#test_df =  test_df[test_df.pitcher == 'Chris Bassitt'].append(test_df[test_df.pitcher != 'Chris Bassitt'])
+
+batter_dict = test_df['batter_name'].to_dict()
+
+colour_palette = ['#FFB000','#648FFF','#785EF0',
+                  '#DC267F','#FE6100','#3D1EB2','#894D80','#16AA02','#B5592B','#A3C1ED']
+
+angle_ev_list_df = pd.read_csv('angle_ev_list_df.csv')
+ev_ranges = list(np.arange(97.5,130,0.1))
+angle_ranges = list(range(8,51))
+#print
+
+
+def server(input,output,session):
+    @output
+    @render.plot(alt="A histogram")
+    def plot():
+        data_df = exit_velo_df[exit_velo_df.batter_id==int(input.id())]
+        #pitch_list = exit_velo_df_small.pitch_type.unique()
+        sns.set_theme(style="whitegrid", palette="pastel")
+        fig, ax = plt.subplots(1, 1, figsize=(10, 10))
+        
+
+
+        if input.plot_id() == 'dist':
+            sns.histplot(x=data_df.launch_angle,y=data_df.launch_speed,cbar=colour_palette,binwidth=(5,2.5),ax=ax,cbar_kws=dict(shrink=.75,label='Count'),binrange=(
+            (math.floor((min(data_df.launch_angle.dropna())/5))*5,math.ceil((max(data_df.launch_angle.dropna())/5))*5),(math.floor((min(data_df.launch_speed.dropna())/5))*5,math.ceil((max(data_df.launch_speed.dropna())/5))*5)))
+        if input.plot_id() == 'scatter':
+            sns.scatterplot(x=data_df.launch_angle,y=data_df.launch_speed,color=colour_palette[1])
+        ax.set_xlim(math.floor((min(data_df.launch_angle.dropna())/10))*10,math.ceil((max(data_df.launch_angle.dropna())/10))*10)
+        #ticks=np.arange(revels.values.min(),revels.values.max()+1 )
+        sns.lineplot(x=angle_ev_list_df.launch_angle,y=angle_ev_list_df.launch_speed,color=colour_palette[0])
+        ax.vlines(x=angle_ev_list_df.launch_angle[0],ymin=angle_ev_list_df.launch_speed[0],ymax=ev_ranges[-1],color=colour_palette[0])
+        ax.vlines(x=angle_ev_list_df.launch_angle[len(angle_ev_list_df)-1],ymin=angle_ev_list_df.launch_speed[len(angle_ev_list_df)-1],ymax=ev_ranges[-1],color=colour_palette[0])
+
+        groundball = f'{sum(data_df.launch_angle.dropna()<=10)/len(data_df.launch_angle.dropna()):.1%}'
+        linedrive = f'{sum((data_df.launch_angle.dropna()<=25) & (data_df.launch_angle.dropna()>10))/len(data_df.launch_angle.dropna()):.1%}'
+        flyball = f'{sum((data_df.launch_angle.dropna()<=50) & (data_df.launch_angle.dropna()>25))/len(data_df.launch_angle.dropna()):.1%}'
+        popup = f'{sum(data_df.launch_angle.dropna()>50)/len(data_df.launch_angle.dropna()):.1%}'
+        percentages_list = [groundball,linedrive,flyball,popup]
+
+        hard_hit_percent = f'{sum(data_df.launch_speed.dropna()>=95)/len(data_df.launch_speed.dropna()):.1%}'
+
+        barrel_percentage = f'{data_df.barrel.dropna().sum()/len(data_df.launch_angle.dropna()):.1%}'
+
+        plt.text(x=27, y=math.ceil((max(data_df.launch_speed.dropna())/5))*5+5-3, s=f'Barrel% {barrel_percentage}',ha='left',bbox=dict(facecolor='white',alpha=0.8, edgecolor=colour_palette[4], pad=5))
+        
+
+        sample_dates = np.array([math.floor((min(data_df.launch_angle.dropna())/10))*10,10,25,50])
+        sample_text = [f'Groundball ({groundball})',f'Line Drive ({linedrive})',f'Fly Ball ({flyball})',f'Pop-up ({popup})']
+
+        hard_hit_dates = [95]
+        hard_hit_text = [f'Hard Hit% ({hard_hit_percent})']
+
+
+
+        #sample_dates = mdates.date2num(sample_dates)
+        plt.hlines(y=hard_hit_dates,xmin=math.floor((min(data_df.launch_angle.dropna())/10))*10, xmax=math.ceil((max(data_df.launch_angle.dropna())/10))*10, color = colour_palette[4],linestyles='--')
+        plt.vlines(x=sample_dates, ymin=0, ymax=130, color = colour_palette[3],linestyles='--')
+
+
+        # ax.vlines(x=10,ymin=0,ymax=ev_ranges[-1],color=colour_palette[3],linestyles='--')
+        # ax.vlines(x=25,ymin=0,ymax=ev_ranges[-1],color=colour_palette[3],linestyles='--')
+        # ax.vlines(x=50,ymin=0,ymax=ev_ranges[-1],color=colour_palette[3],linestyles='--')
+
+
+
+        for i, x in enumerate(hard_hit_dates):
+            text(math.ceil((max(data_df.launch_angle.dropna())/10))*10-2.5, x+1.25,hard_hit_text[i], rotation=0, ha='right',
+                bbox=dict(facecolor='white',alpha=0.5, edgecolor=colour_palette[4], pad=5))
+
+
+        for i, x in enumerate(sample_dates):
+            text(x+0.75, (math.floor((min(data_df.launch_speed.dropna())/5))*5)+1,sample_text[i], rotation=90, verticalalignment='bottom',
+                bbox=dict(facecolor='white',alpha=0.5, edgecolor=colour_palette[3], pad=5))
+        #ax.vlines(x=math.floor((min(data_df.launch_angle.dropna())/10))*10+1,ymin=0,ymax=ev_ranges[-1],color=colour_palette[3],linestyles='--')
+
+        ax.set_xlim((math.floor((min(data_df.launch_angle.dropna())/10))*10,math.ceil((max(data_df.launch_angle.dropna())/10))*10))
+        ax.set_ylim((math.floor((min(data_df.launch_speed.dropna())/5))*5,math.ceil((max(data_df.launch_speed.dropna())/5))*5+5))
+        # ax.set_xlim(-90,90)
+        # ax.set_ylim(0,125)
+        ax.set_title(f'MLB - {data_df.batter_name.unique()[0]} Launch Angle vs EV Plot', fontsize=18,fontname='Century Gothic',)
+        #vals = ax.get_yticks()
+        ax.set_xlabel('Launch Angle', fontsize=16,fontname='Century Gothic')
+        ax.set_ylabel('Exit Velocity', fontsize=16,fontname='Century Gothic')
+        ax.fill_between(angle_ev_list_df.launch_angle, 130, angle_ev_list_df.launch_speed, interpolate=True, color=colour_palette[3],alpha=0.1,label='Barrel')
+        #fig.colorbar(plot_dist, ax=ax)
+        #fig.colorbar(plot_dist)
+        #fig.axes[0].invert_yaxis()
+        ax.legend(fontsize='16',loc='upper left')
+        fig.text(x=0.03,y=0.02,s='By: @TJStats')
+        fig.text(x=1-0.03,y=0.02,s='Data: MLB',ha='right')
+
+        # fig.text(x=0.25,y=0.02,s='Data: MLB',ha='right')
+        # fig.text(x=0.25,y=0.02,s='Data: MLB',ha='right')
+        # fig.text(x=0.25,y=0.02,s='Data: MLB',ha='right')
+        #cbar = plt.colorbar()
+        #fig.subplots_adjust(wspace=.02, hspace=.02)
+        #ax.xaxis.set_major_formatter(FuncFormatter(lambda x, _: int(x)))
+        fig.set_facecolor('white')
+        fig.tight_layout()
+        #matplotlib.rcParams["figure.dpi"] = 300
+
+            # ax.set_xlim(input.n(),exit_velo_df_small.pitch.max())
+            #ax.axis('off')
+        
+        #fig.set_facecolor('white')
+        #fig.tight_layout()
+        #ax.hist(exit_velo_df[exit_velo_df.pitcher_id==int(input.id())]['pitch_velocity'],input.n(),density=True)
+        #plt.show()
+        #return g 
+
+# This is a shiny.App object. It must be named `app`.
+
+# fig, ax = plt.subplots()
+#print(input.pitcher_id())
+# print(input)
+# plt.hist(x=exit_velo_df[exit_velo_df.pitcher_id==input.x()]['pitch_velocity'])
+# plt.show()
+
+
+ev_angle = 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.navset_tab(
+        ui.nav_control(
+             ui.a(
+                "Home",
+                href="home/"
+            ),
+        ),
+        ui.nav_menu(
+            "Batter Charts",
+            ui.nav_control(
+             ui.a(
+                "Spray",
+                href="spray/"
+            ),
+            ui.a(
+                "Decision Value",
+                href="decision_value/"
+            ),
+            ui.a(
+                "Damage Model",
+                href="damage_model/"
+            ),
+            ui.a(
+                "Batter Scatter",
+                href="batter_scatter/"
+            ),
+            ui.a(
+                "EV vs LA Plot",
+                href="ev_angle/"
+            )
+        ),
+        ),
+        ui.nav_menu(
+            "Goalie Charts",
+            ui.nav_control(
+             ui.a(
+                "GSAx Timeline",
+                href="gsax-timeline/"
+            ),
+             ui.a(
+                "GSAx Leaderboard",
+                href="gsax-leaderboard/"
+            ),
+             ui.a(
+                "GSAx Comparison",
+                href="gsax-comparison/"
+            )
+        ),
+        ),ui.nav_menu(
+            "Team Charts",
+            ui.nav_control(
+             ui.a(
+                "Team xG Rates",
+                href="team-xg-rates/"
+            ),
+        ),
+        ),ui.nav_control(
+             ui.a(
+                "Games",
+                href="games/"
+            ),
+        ),ui.nav_control(
+             ui.a(
+                "About",
+                href="about/"
+            ),
+        ),ui.nav_control(
+             ui.a(
+                "Articles",
+                href="articles/"
+            ),
+        )),ui.row(
+    ui.layout_sidebar(
+        
+   
+
+
+      ui.panel_sidebar(
+        ui.input_select("id", "Select Batter",batter_dict,width=1),
+        ui.input_select("plot_id", "Select Plot",{'scatter':'Scatter Plot','dist':'Distribution Plot'},width=1)
+      ),
+
+      ui.panel_main(
+        ui.output_plot("plot",height = "1000px",width="1000px")
+      ),
+    )),)),server)

home.py

@@ -14,7 +14,7 @@ from configure import base_url
 home = App(ui.page_fluid(
     ui.tags.base(href=base_url),
     ui.tags.div(
-         {"style": "width:75%;margin: 0 auto;max-width: 1500px;"},
+         {"style": "width:90%;margin: 0 auto;max-width: 1600px;"},
         ui.tags.style(
             """
             h4 {
@@ -25,8 +25,9 @@ home = App(ui.page_fluid(
             }
             """
          ),
-    shinyswatch.theme.darkly(),ui.tags.h4("Stats By Zach"),
-    ui.tags.i("A website for hockey analytics"),
+    shinyswatch.theme.simplex(),
+    ui.tags.h4("TJStats"),
+    ui.tags.i("Baseball Analytics and Visualizations"),
     ui.navset_tab(
         ui.nav_control(
              ui.a(
@@ -35,16 +36,28 @@ home = App(ui.page_fluid(
             ),
         ),
         ui.nav_menu(
-            "Skater Charts",
+            "Batter Charts",
             ui.nav_control(
              ui.a(
-                "On-Ice xG Rates",
-                href="skater-xg-rates/"
+                "Spray",
+                href="spray/"
             ),
             ui.a(
-                "On-Ice xGF%",
-                href="skater-xg-percentages/"
+                "Decision Value",
+                href="decision_value/"
             ),
+            ui.a(
+                "Damage Model",
+                href="damage_model/"
+            ),
+            ui.a(
+                "Batter Scatter",
+                href="batter_scatter/"
+            ),
+            ui.a(
+                "EV vs LA Plot",
+                href="ev_angle/"
+            )
         ),
         ),
         ui.nav_menu(
@@ -86,4 +99,4 @@ home = App(ui.page_fluid(
                 "Articles",
                 href="articles/"
             ),
-        )),ui.tags.br(),ui.tags.h5("Welcome to Stats By Zach!"),ui.tags.h6("The 2023-24 NHL regular season is here, and the StatsByZach website is officially up and running for it! As I've state before, this website is still a work in progress, with lots of work to be done in terms of styling and compatibility especially. Along with that, I am focusing on finding a new hosting solution, adding more charts, and some prerformace enhancements as well. Thank you for paying the site a visit, and I do hope you can use my data to better understand the NHL. The website gets updated daily, and I try to make improvements on a regular basis, so please do visit the site often, and feel free to reach out to me on Twitter @StatsByZach for any feedback or suggestions. Enjoy the site, and happy hockey season!"))), None)
+        )),ui.tags.br(),ui.tags.h5("Welcome to TJStats!"),ui.tags.h6(""))), None)

manifest.json

@@ -0,0 +1,33 @@
+{
+  "version": 1,
+  "locale": "en_CA.cp1252",
+  "metadata": {
+    "appmode": "python-shiny",
+    "entrypoint": "app"
+  },
+  "python": {
+    "version": "3.9.13",
+    "package_manager": {
+      "name": "pip",
+      "version": "23.1",
+      "package_file": "requirements.txt"
+    }
+  },
+  "files": {
+    "requirements.txt": {
+      "checksum": "d9ed48c97a63d10c292a5a380e83b577"
+    },
+    ".dockerignore": {
+      "checksum": "abd9778fec883c042a294e6f8ec4d95f"
+    },
+    "Dockerfile": {
+      "checksum": "ad90b7a7fd00daa424a233ac74027c3f"
+    },
+    "app.py": {
+      "checksum": "9ede9917d07c102f70acc73a105debdf"
+    },
+    "runtime.txt": {
+      "checksum": "d500af0d9f1bed234ef59fa020da5bf1"
+    }
+  }
+}

no_swing.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c3da3e7ab2b513b87d05e90ae30c788ac819dfcaa7cc1cd9943fc13d2958a00f
+size 279409

requirements.txt

@@ -1,18 +1,310 @@
 # requirements.txt generated by rsconnect-python on 2023-04-20 21:38:50.254957
-#adjustText==0.8
-#dataframe_image==0.1.11
-datasets==2.16.1
-inflect==7.0.0
+adjustText==0.7.3
+aiohttp==3.8.1
+aiosignal==1.2.0
+altair==4.2.0
+ansicolors==1.1.8
+anyio==3.6.2
+appdirs==1.4.4
+argon2-cffi==21.1.0
+asgiref==3.5.2
+aspose-words==22.10.0
+asttokens==2.2.1
+async-timeout==4.0.2
+atomicwrites==1.4.0
+attrs==20.3.0
+backcall==0.2.0
+bandit==1.7.4
+baseball-scraper==0.4.10
+beautifulsoup4==4.9.3
+bleach==4.1.0
+branca==0.4.2
+bs4==0.0.1
+cachetools==5.2.0
+cairocffi==1.2.0
+CairoSVG==2.6.0
+calfem-python==3.5.9
+certifi==2020.12.5
+cffi==1.14.5
+chardet==4.0.0
+charset-normalizer==2.0.11
+chart-studio==1.1.0
+click==8.1.3
+click-plugins==1.1.1
+cligj==0.7.2
+colorama==0.4.4
+colour==0.1.5
+commonmark==0.9.1
+contextvars==2.4
+coverage==6.5.0
+cryptography==38.0.1
+cssselect==1.1.0
+cssselect2==0.4.1
+cssutils==2.2.0
+cycler==0.10.0
+dash==2.9.3
+dash-core-components==2.0.0
+dash-html-components==2.0.0
+dash-table==5.0.0
+dataframe-image==0.1.7
+DateTime==4.3
+decorator==4.4.2
+decorest==0.0.6
+defusedxml==0.7.1
+Deprecated==1.2.13
+deserialize==1.8.1
+df2img==0.2.9
+Django==4.1.1
+dmsh==0.2.19
+docopt==0.6.2
+entrypoints==0.3
+et-xmlfile==1.0.1
+executing==1.2.0
+ezdxf==0.17.2
+fastapi==0.95.0
+fastjsonschema==2.16.3
+flake8==5.0.4
+Flask==2.2.3
+folium==0.12.1.post1
+fonttools==4.31.2
+frozenlist==1.3.0
+fsspec==2023.4.0
+fuzzywuzzy==0.18.0
+geomdl==5.3.1
+gitdb==4.0.9
+GitPython==3.1.29
+gmsh==4.9.5
+google-api-core==2.10.1
+google-api-python-client==2.63.0
+google-auth==2.12.0
+google-auth-httplib2==0.1.0
+google-auth-oauthlib==0.5.3
+google-spreadsheet==0.0.6
+googleapis-common-protos==1.56.4
+graphviz==0.19.1
+greenlet==1.1.3.post0
+gspread==5.5.0
+h11==0.12.0
+h5py==3.6.0
+hockey-rink==0.1.1
+hockey-scraper==1.37.1
+hockeyjockey==1.2
+html2image==2.0.1
+html5lib==1.1
+htmltools==0.2.1
+httpcore==0.15.0
+httplib2==0.20.4
+httpx==0.23.0
+humanize==4.6.0
+idna==2.10
+image==1.5.33
+imageio==2.15.0
+imageio-ffmpeg==0.4.8
+imgkit==1.2.2
+immutables==0.19
+importlib-metadata==6.0.0
+importlib-resources==5.12.0
+iniconfig==1.1.1
+ipykernel==5.5.0
+ipython==8.11.0
+ipython-genutils==0.2.0
+itsdangerous==2.1.2
+jdcal==1.4.1
+jedi==0.18.0
+Jinja2==3.0.1
+joblib==1.1.0
+jsonschema==3.2.0
+jupyter-client==6.1.11
+jupyter-core==4.7.1
+jupyterlab-pygments==0.1.2
+kaleido==0.2.1
+kiwisolver==1.3.1
+libhockey==0.23.0
+linkify-it-py==2.0.0
+lxml==4.6.2
+markdown-it-py==2.2.0
+MarkupSafe==2.1.2
 matplotlib==3.5.1
-numpy==1.23.5
-pandas==1.5.2
+matplotlib-inline==0.1.6
+mccabe==0.7.0
+mdit-py-plugins==0.3.5
+mdurl==0.1.2
+menyou==1.0
+meshio==5.3.4
+meshplex==0.17.2
+meshzoo==0.9.4
+mistune==0.8.4
+MLB-StatsAPI==1.4.2
+more-itertools==8.12.0
+moviepy==1.0.3
+mpmath==1.2.1
+multidict==6.0.2
+munch==2.5.0
+mysql-connector-python==8.0.24
+natsort==7.1.1
+nbclient==0.5.4
+nbconvert==6.4.0
+nbformat==5.1.3
+ndim==0.1.6
+nest-asyncio==1.5.1
+networkx==2.6.3
+nhl-logo-scraper==1.1.0
+nhlpy==0.3.0
+nibabel==3.2.2
+notebook==6.4.4
+npx==0.1.1
+numpy==1.22.3
+oauth2client==4.1.3
+oauthlib==3.2.1
+openpyxl==3.0.5
+optimesh==0.8.7
+orthopy==0.9.5
+packaging==21.3
+pandas==1.2.0
+pandocfilters==1.5.0
+parso==0.8.1
+patsy==0.5.1
+pbr==5.11.0
+pdfkit==1.0.0
+pickleshare==0.7.5
 Pillow==9.0.1
-plotly==5.14.1
-#Pillow==10.0.0
-Requests==2.31.0
-scipy==1.11.1
+pins==0.8.0
+pip==23.1
+platformdirs==2.5.1
+plotly==4.1.1
+pluggy==0.13.1
+praw==7.7.0
+prawcore==2.3.0
+proglog==0.1.10
+prometheus-client==0.11.0
+prompt-toolkit==3.0.38
+protobuf==4.21.6
+psutil==5.9.3
+pure-eval==0.2.2
+py==1.10.0
+pyaml==20.4.0
+pyarrow==5.0.0
+pyasn1==0.4.8
+pyasn1-modules==0.2.8
+pybaseball==2.2.1
+pybind11==2.9.1
+pycairo==1.23.0
+pycodestyle==2.9.1
+pycparser==2.20
+pydantic==1.10.7
+pyfiglet==0.8.post1
+pyflakes==2.5.0
+PyGithub==1.55
+Pygments==2.8.0
+pygsheets==2.0.5
+PyHockeyStats==0.5.2
+PyJWT==2.6.0
+pymesh==1.0.2
+PyNaCl==1.4.0
+PyOpenGL==3.1.6
+pyOpenSSL==22.1.0
+pyparsing==3.0.7
+pyperclip==1.8.2
+pyproj==3.2.1
+PyQt5==5.15.6
+PyQt5-Qt5==5.15.2
+PyQt5-sip==12.9.1
+PyQtWebEngine==5.15.5
+PyQtWebEngine-Qt5==5.15.2
+pyrsistent==0.17.3
+pytest==7.1.3
+pytest_check==1.0.5
+python-dateutil==2.8.2
+python-dotenv==0.21.0
+python-mlb-statsapi==0.3.9
+python-multipart==0.0.6
+pytools==2022.1.1
+pytz==2022.7.1
+PyVTK==0.5.18
+PyWavelets==1.2.0
+pywin32==305
+pywinpty==1.1.4
+PyYAML==5.3.1
+pyzmq==25.0.1
+quadpy==0.16.10
+rauth==0.7.3
+requests==2.28.1
+requests-mock==1.10.0
+requests-oauthlib==1.3.1
+retrying==1.3.3
+rfc3986==1.5.0
+rhino-shapley-interop==0.0.4
+rhino3dm==7.15.0
+rich==12.0.0
+riotwatcher==3.2.4
+rsa==4.9
+scikit-image==0.19.1
+scikit-learn==1.0.1
+scipy==1.6.0
 seaborn==0.11.1
-shiny==0.6.1
-shinywidgets
-shinyswatch
-starlette==0.26.1
+selenium==3.141.0
+semver==2.13.0
+Send2Trash==1.8.0
+Shapely==1.7.1
+shiny==0.3.0
+six==1.16.0
+sklearn==0.0
+smmap==5.0.0
+sniffio==1.3.0
+soupsieve==2.4
+spotipy==2.18.0
+SQLAlchemy==1.4.42
+sqlparse==0.4.2
+stack-data==0.6.2
+starlette==0.26.1
+statsmodels==0.12.2
+stevedore==4.1.1
+stringcase==1.2.0
+sympy==1.10
+tabulate==0.9.0
+tekore==4.5.0
+tenacity==8.2.2
+terminado==0.12.1
+termplotlib==0.3.9
+testpath==0.5.0
+threadpoolctl==3.0.0
+tifffile==2022.2.2
+tinycss2==1.2.1
+toml==0.10.2
+tomli==2.0.1
+toolz==0.11.2
+TopDownHockey-Scraper==2.0.1
+tornado==6.2
+tqdm==4.62.3
+traitlets==5.9.0
+triangle==20220202
+trimeshpy==0.0.2
+tweepy==4.13.0
+typing_extensions==4.5.0
+tzdata==2022.2
+uc-micro-py==1.0.1
+Unidecode==1.3.4
+update-checker==0.18.0
+uritemplate==4.1.1
+urllib3==1.26.15
+uvicorn==0.21.1
+vega-datasets==0.9.0
+visvis==1.13.0
+vtk==9.1.0
+wcwidth==0.2.6
+webdriver-manager==3.8.5
+webencodings==0.5.1
+websocket-client==1.5.1
+websockets==11.0.1
+Werkzeug==2.2.3
+wget==3.2
+wrapt==1.12.1
+wslink==1.4.3
+xmltodict==0.12.0
+xxhash==3.2.0
+yahoo-oauth==2.0
+yarl==1.7.2
+yffpy==2.11.0
+yfpy==9.1.0
+zipp==3.15.0
+zope.interface==5.4.0

runtime.txt

@@ -0,0 +1 @@
+python-3.9.13

spray.py

@@ -0,0 +1,437 @@
+##### games.,py #####
+
+# Import modules
+from shiny import *
+import shinyswatch
+import plotly.express as px
+from shinywidgets import output_widget, render_widget
+import pandas as pd
+from configure import base_url
+import math
+import datetime
+import datasets
+from datasets import load_dataset
+import numpy as np
+import matplotlib
+from matplotlib.ticker import MaxNLocator
+from matplotlib.gridspec import GridSpec
+import matplotlib.pyplot as plt
+from scipy.stats import gaussian_kde
+
+### Import Datasets
+dataset = load_dataset('nesticot/mlb_data', data_files=['mlb_pitch_data_2023.csv',
+                                                        'mlb_pitch_data_2022.csv'])
+dataset_train = dataset['train']
+df_2023 = dataset_train.to_pandas().set_index(list(dataset_train.features.keys())[0]).reset_index(drop=True)
+# Paths to data
+### Normalize Hit Locations
+df_2023['hit_x'] = df_2023['hit_x'] - 126#df_2023['hit_x'].median()
+df_2023['hit_y'] = -df_2023['hit_y']+204.5#df_2023['hit_y'].quantile(0.9999)
+
+df_2023['hit_x_og'] = df_2023['hit_x']
+df_2023.loc[df_2023['batter_hand'] == 'R','hit_x'] = -1*df_2023.loc[df_2023['batter_hand'] == 'R','hit_x']
+
+### Calculate Horizontal Launch Angles
+df_2023['h_la'] = np.arctan(df_2023['hit_x'] / df_2023['hit_y'])*180/np.pi
+conditions_ss = [
+    (df_2023['h_la']<-16+5/6),
+    (df_2023['h_la']<16+5/6)&(df_2023['h_la']>=-16+5/6),
+    (df_2023['h_la']>=16+5/6)
+]
+
+choices_ss = ['Oppo','Straight','Pull']
+df_2023['traj'] = np.select(conditions_ss, choices_ss, default=np.nan)
+df_2023['bip'] = [1 if x > 0  else np.nan for x in df_2023['launch_speed']]
+
+conditions_woba = [
+        (df_2023['event_type']=='walk'),
+        (df_2023['event_type']=='hit_by_pitch'),
+        (df_2023['event_type']=='single'),
+        (df_2023['event_type']=='double'),
+        (df_2023['event_type']=='triple'),
+        (df_2023['event_type']=='home_run'),
+    ]
+
+choices_woba = [0.698,
+                    0.728,
+                    0.887,
+                    1.253,
+                    1.583,
+                    2.027]
+
+df_2023['woba'] = np.select(conditions_woba, choices_woba, default=0)
+
+
+
+df_2023_bip = df_2023[~df_2023['bip'].isnull()].dropna(subset=['h_la','launch_angle'])
+df_2023_bip['h_la'] = df_2023_bip['h_la'].round(0)
+
+
+df_2023_bip['season'] = df_2023_bip['game_date'].str[0:4].astype(int)
+
+df_2023_bip = df_2023_bip[df_2023_bip['season'] == 2023]
+df_2022_bip = df_2023_bip[df_2023_bip['season'] == 2022]
+
+batter_dict = df_2023_bip.sort_values('batter_name').set_index('batter_id')['batter_name'].to_dict()
+
+
+
+
+
+def server(input,output,session):
+    @output
+    @render.plot(alt="plot")
+    def plot():
+
+        batter_id_select = int(input.batter_id())
+        df_batter_2023 = df_2023_bip.loc[(df_2023_bip['batter_id'] == batter_id_select)&(df_2023_bip['season']==2023)]
+        df_batter_2022 = df_2023_bip.loc[(df_2023_bip['batter_id'] == batter_id_select)&(df_2023_bip['season']==2022)]
+
+        df_non_batter_2023 = df_2023_bip.loc[(df_2023_bip['batter_id'] != batter_id_select)&(df_2023_bip['season']==2023)]
+        df_non_batter_2022 = df_2023_bip.loc[(df_2023_bip['batter_id'] != batter_id_select)&(df_2023_bip['season']==2022)]
+
+        traj_df = df_batter_2023.groupby(['traj'])['launch_speed'].count() / len(df_batter_2023)
+        trajectory_df = df_batter_2023.groupby(['trajectory'])['launch_speed'].count() / len(df_batter_2023)#.loc['Oppo']
+
+
+
+
+        colour_palette = ['#FFB000','#648FFF','#785EF0',
+                        '#DC267F','#FE6100','#3D1EB2','#894D80','#16AA02','#B5592B','#A3C1ED']
+        
+        fig = plt.figure(figsize=(10, 10))
+
+
+
+        # Create a 2x2 grid of subplots using GridSpec
+        gs = GridSpec(3, 3, width_ratios=[0.1,0.8,0.1], height_ratios=[0.1,0.8,0.1])
+
+        # ax00 = fig.add_subplot(gs[0, 0]) 
+        ax01 = fig.add_subplot(gs[0, :])  # Subplot at the top-right position
+        # ax02 = fig.add_subplot(gs[0, 2])
+        # Subplot spanning the entire bottom row
+        ax10 = fig.add_subplot(gs[1, 0]) 
+        ax11 = fig.add_subplot(gs[1, 1])  # Subplot at the top-right position
+        ax12 = fig.add_subplot(gs[1, 2])
+        # ax20 = fig.add_subplot(gs[2, 0]) 
+        ax21 = fig.add_subplot(gs[2, :])  # Subplot at the top-right position
+        # ax22 = fig.add_subplot(gs[2, 2])
+
+        initial_position = ax12.get_position()
+
+        # Change the size of the axis
+        # new_width = 0.06  # Set your desired width
+        # new_height = 0.4  # Set your desired height
+        # new_position = [initial_position.x0-0.01, initial_position.y0+0.065, new_width, new_height]
+        # ax12.set_position(new_position)
+
+        cmap_hue = matplotlib.colors.LinearSegmentedColormap.from_list("", [colour_palette[1],'#ffffff',colour_palette[0]])
+        # Generate two sets of two-dimensional data
+        # data1 = np.random.multivariate_normal([0, 0], [[1, 0.5], [0.5, 1]], 1000)
+        # data2 = np.random.multivariate_normal([3, 3], [[1, -0.5], [-0.5, 1]], 1000)
+        bat_hand = df_batter_2023.groupby('batter_hand')['launch_speed'].count().sort_values(ascending=False).index[0]
+
+        bat_hand_value = 1
+
+        if bat_hand == 'R':
+            bat_hand_value = -1
+
+        kde1_df = df_batter_2023[['h_la','launch_angle']]
+        kde1_df['h_la'] = kde1_df['h_la'] * bat_hand_value
+        kde2_df = df_non_batter_2023[['h_la','launch_angle']].sample(n=50000, random_state=42)
+        kde2_df['h_la'] = kde2_df['h_la'] * bat_hand_value
+
+
+        # Calculate 2D KDE for each dataset
+        kde1 = gaussian_kde(kde1_df.values.T)
+        kde2 = gaussian_kde(kde2_df.values.T)
+
+        # Generate a grid of points for evaluation
+        x, y = np.meshgrid(np.arange(-45, 46,1 ), np.arange(-30, 61,1 ))
+        positions = np.vstack([x.ravel(), y.ravel()])
+
+        # Evaluate the KDEs on the grid
+        kde1_values = np.reshape(kde1(positions).T, x.shape)
+        kde2_values = np.reshape(kde2(positions).T, x.shape)
+
+        # Subtract one KDE from the other
+        result_kde_values = kde1_values - kde2_values
+
+        # Normalize the array to the range [0, 1]
+        # result_kde_values = (result_kde_values - np.min(result_kde_values)) / (np.max(result_kde_values) - np.min(result_kde_values))
+        result_kde_values = (result_kde_values - np.mean(result_kde_values)) / (np.std(result_kde_values))
+
+        result_kde_values = np.clip(result_kde_values, -3, 3)
+        # # Plot the original KDEs
+        # plt.contourf(x, y, kde1_values, cmap='Blues', alpha=0.5, levels=20)
+        # plt.contourf(x, y, kde2_values, cmap='Reds', alpha=0.5, levels=20)
+
+        # Plot the subtracted KDE
+        # Set the number of levels and midrange value
+        # Set the number of levels and midrange value
+        num_levels = 14
+        midrange_value = 0
+
+        # Create a filled contour plot with specified levels
+        levels = np.linspace(-3, 3, num_levels)
+
+        batter_plot = ax11.contourf(x, y, result_kde_values, cmap=cmap_hue, levels=levels, vmin=-3, vmax=3)
+
+
+        ax11.hlines(y=10,xmin=45,xmax=-45,color=colour_palette[3],linewidth=1)
+        ax11.hlines(y=25,xmin=45,xmax=-45,color=colour_palette[3],linewidth=1)
+        ax11.hlines(y=50,xmin=45,xmax=-45,color=colour_palette[3],linewidth=1)
+
+        ax11.vlines(x=-15,ymin=-30,ymax=60,color=colour_palette[3],linewidth=1)
+        ax11.vlines(x=15,ymin=-30,ymax=60,color=colour_palette[3],linewidth=1)
+        #ax11.axis('square')
+        #ax11.axis('off')
+        #ax.hlines(y=10,xmin=-45,xmax=-45)
+        # Add labels and legend
+        #plt.xlabel('X-axis')
+        #plt.ylabel('Y-axis')
+        #ax.plot('equal')
+        #plt.gca().set_aspect('equal')
+
+        #Choose a mappable (can be any plot or image)
+        ax12.set_ylim(0,1)
+        cbar = plt.colorbar(batter_plot, cax=ax12, orientation='vertical',shrink=1)
+        cbar.set_ticks([])
+        # Set the colorbar to have 13 levels
+        cbar_locator = MaxNLocator(nbins=13)
+        cbar.locator = cbar_locator
+        cbar.update_ticks()
+        #cbar.set_clim(vmin=-3, vmax=)
+        # Set ticks and tick labels
+        # cbar.set_ticks(np.linspace(-3, 3, 13))
+        # cbar.set_ticklabels(np.linspace(0, 3, 13))
+        cbar.set_ticks([])
+
+
+
+
+        ax10.text(s=f"Pop Up\n({trajectory_df.loc['popup']:.1%})",
+                x=1,
+                y=0.95,va='center',ha='right',fontsize=16)
+        # Choose a mappable (can be any plot or image)
+        ax10.text(s=f"Fly Ball\n({trajectory_df.loc['fly_ball']:.1%})",
+                x=1,
+                y=0.75,va='center',ha='right',fontsize=16)
+
+        ax10.text(s=f"Line\nDrive\n({trajectory_df.loc['line_drive']:.1%})",
+                x=1,
+                y=0.53,va='center',ha='right',fontsize=16)
+
+
+        ax10.text(s=f"Ground\nBall\n({trajectory_df.loc['ground_ball']:.1%})",
+                x=1,
+                y=0.23,va='center',ha='right',fontsize=16)
+        #ax12.axis(True)
+        # Set equal aspect ratio for the contour plot
+
+        if bat_hand == 'R':
+
+
+            ax21.text(s=f"Pull\n({traj_df.loc['Pull']:.1%})",
+                    x=0.2+1/16*0.8,
+                    y=1,va='top',ha='center',fontsize=16)
+
+            ax21.text(s=f"Straight\n({traj_df.loc['Straight']:.1%})",
+                    x=0.5,
+                    y=1,va='top',ha='center',fontsize=16)
+
+            ax21.text(s=f"Oppo\n({traj_df.loc['Oppo']:.1%})",
+                    x=0.8-1/16*0.8,
+                    y=1,va='top',ha='center',fontsize=16)
+
+        else:
+
+            ax21.text(s=f"Pull\n({traj_df.loc['Pull']:.1%})",
+                    x=0.8-1/16*0.8,
+                    y=1,va='top',ha='center',fontsize=16)
+
+            ax21.text(s=f"Straight\n({traj_df.loc['Straight']:.1%})",
+                    x=0.5,
+                    y=1,va='top',ha='center',fontsize=16)
+
+            ax21.text(s=f"Oppo\n({traj_df.loc['Oppo']:.1%})",
+                    x=0.2+1/16*0.8,
+                    y=1,va='top',ha='center',fontsize=16)
+            
+        # Define the initial position of the axis
+
+        # Customize colorbar properties
+        # cbar = fig.colorbar(orientation='vertical', pad=0.1,ax=ax12)
+        #cbar.set_label('Difference', rotation=270, labelpad=15)
+        # Show the plot
+        # ax21.text(0.0, 0., "By: Thomas Nestico\n      @TJStats",ha='left', va='bottom',fontsize=12)
+        # ax21.text(1, 0., "Data: MLB",ha='right', va='bottom',fontsize=12)
+        # ax21.text(0.5, 0., "Inspired by @blandalytics",ha='center', va='bottom',fontsize=12)
+
+        # ax00.axis('off')
+        ax01.axis('off')
+        # ax02.axis('off')
+        ax10.axis('off')
+        #ax11.axis('off')
+        #ax12.axis('off')
+        # ax20.axis('off')
+        ax21.axis('off')
+        # ax22.axis('off')
+
+        ax21.text(0.0, 0., "By: Thomas Nestico\n      @TJStats",ha='left', va='bottom',fontsize=12)
+        ax21.text(0.98, 0., "Data: MLB",ha='right', va='bottom',fontsize=12)
+        ax21.text(0.5, 0., "Inspired by @blandalytics",ha='center', va='bottom',fontsize=12)
+
+
+        ax11.set_xticks([])
+        ax11.set_yticks([])
+
+        # ax12.text(s='Same',x=np.mean([x for x in ax12.get_xlim()]),y=np.median([x for x in ax12.get_ylim()]),
+        #           va='center',ha='center',fontsize=12)
+
+        # ax12.text(s='More\nOften',x=0.5,y=0.74,
+        #         va='top',ha='center',fontsize=12)
+
+        ax12.text(s='+3σ',x=0.5,y=3-1/14*3,
+                va='center',ha='center',fontsize=12)
+
+        ax12.text(s='+2σ',x=0.5,y=2-1/14*2,
+                va='center',ha='center',fontsize=12)
+
+        ax12.text(s='+1σ',x=0.5,y=1-1/14*1,
+                va='center',ha='center',fontsize=12)
+
+
+        ax12.text(s='±0σ',x=0.5,y=0,
+                va='center',ha='center',fontsize=12)
+
+        ax12.text(s='-1σ',x=0.5,y=-1-1/14*-1,
+                va='center',ha='center',fontsize=12)
+
+        ax12.text(s='-2σ',x=0.5,y=-2-1/14*-2,
+                va='center',ha='center',fontsize=12)
+
+        ax12.text(s='-3σ',x=0.5,y=-3-1/14*-3,
+                va='center',ha='center',fontsize=12)
+
+        # # ax12.text(s='Less\nOften',x=0.5,y=0.26,
+        # #         va='bottom',ha='center',fontsize=12)
+
+        ax01.text(s=f"{df_batter_2023['batter_name'].values[0]}'s 2023 Batted Ball Tendencies",
+                x=0.5,
+                y=0.8,va='top',ha='center',fontsize=20)
+
+        ax01.text(s=f"(Compared to rest of MLB)",
+                x=0.5,
+                y=0.3,va='top',ha='center',fontsize=16)
+        
+        #plt.show()
+
+spray = 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("Stats By Zach"),
+    ui.tags.i("A website for hockey analytics"),
+    ui.navset_tab(
+        ui.nav_control(
+             ui.a(
+                "Home",
+                href="home/"
+            ),
+        ),
+        ui.nav_menu(
+            "Batter Charts",
+            ui.nav_control(
+             ui.a(
+                "Spray",
+                href="spray/"
+            ),
+            ui.a(
+                "Decision Value",
+                href="decision_value/"
+            ),
+            ui.a(
+                "Damage Model",
+                href="damage_model/"
+            ),
+            ui.a(
+                "Batter Scatter",
+                href="batter_scatter/"
+            ),
+            ui.a(
+                "EV vs LA Plot",
+                href="ev_angle/"
+            )
+        ),
+        ),
+        ui.nav_menu(
+            "Goalie Charts",
+            ui.nav_control(
+             ui.a(
+                "GSAx Timeline",
+                href="gsax-timeline/"
+            ),
+             ui.a(
+                "GSAx Leaderboard",
+                href="gsax-leaderboard/"
+            ),
+             ui.a(
+                "GSAx Comparison",
+                href="gsax-comparison/"
+            )
+        ),
+        ),ui.nav_menu(
+            "Team Charts",
+            ui.nav_control(
+             ui.a(
+                "Team xG Rates",
+                href="team-xg-rates/"
+            ),
+        ),
+        ),ui.nav_control(
+             ui.a(
+                "Games",
+                href="games/"
+            ),
+        ),ui.nav_control(
+             ui.a(
+                "About",
+                href="about/"
+            ),
+        ),ui.nav_control(
+             ui.a(
+                "Articles",
+                href="articles/"
+            ),
+        )),ui.row(
+    ui.layout_sidebar(
+        
+        ui.panel_sidebar(
+                ui.input_select("batter_id",
+                                "Select Batter",
+                                 batter_dict,
+                                 width=1,
+                                 size=1,
+                                 selectize=True)),
+
+   ui.panel_main(     
+        ui.navset_tab(
+
+            ui.nav("2023 vs MLB",
+                   ui.output_plot('plot',
+                                  width='1000px',
+                                  height='1000px')),
+        ))
+    )),)),server)

swing.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fef4a66363e5f3fdc70ae45c5382bd986c800ff8bf9296a1f9b334461e70fd4
+size 262137

xtb_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a0b08278fdbb8c3bc2af79a65e9563e8b8d2251072ae90fc772ce7b4d2937b7d
+size 14497085