Upload app.py

app.py

@@ -0,0 +1,706 @@
+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 inflect
+from matplotlib.pyplot import text
+
+def percentile(n):
+    def percentile_(x):
+        return np.nanpercentile(x, n)
+    percentile_.__name__ = 'percentile_%s' % n
+    return percentile_
+
+from matplotlib.colors import Normalize
+
+print('Running')
+
+cmap = matplotlib.colors.LinearSegmentedColormap.from_list("", ["#4285F4","white","#FBBC04"])
+df = pd.read_csv('statcast_20152023.csv')
+df['last_name'] = df['last_name, first_name'].str.split(',').str[0]
+df['first_name'] = df['last_name, first_name'].str.split(',').str[1].str.strip(' ')
+df['name'] = df['first_name'] +' ' +df['last_name']
+
+df[[x for x in df if x[-7:] == 'percent']] = df[[x for x in df if x[-7:] == 'percent']]/100
+df['barrel_batted_rate'] = df['barrel_batted_rate']/100
+
+player_dict = df[['player_id','name']].drop_duplicates().sort_values('name').set_index('player_id').to_dict()['name']
+
+df_median = df[df.pa>=400]
+
+format_dict = {
+ 'k_percent':{'format':':.1%','average':df.strikeout.sum()/df.pa.sum(),'a_d_good':False,'tab_name':'K%'},
+ 'bb_percent':{'format':':.1%','average':df.walk.sum()/df.pa.sum(),'a_d_good':True,'tab_name':'BB%'},
+ 'batting_avg':{'format':':.3f','average':df.hit.sum()/df.ab.sum(),'a_d_good':True,'tab_name':'AVG'},
+ 'on_base_plus_slg':{'format':':.3f','average':df.on_base_plus_slg.mean()/df.pa.mean(),'a_d_good':True,'tab_name':'OPS'},
+ 'isolated_power':{'format':':.3f','average':(df.single.sum() + df.double.sum()*2 + df.triple.sum()*3 + df.home_run.sum()*4)/df.ab.sum() - df.hit.sum()/df.ab.sum(),'a_d_good':True,'tab_name':'ISO'},
+ 'xba':{'format':':.3f','average':df_median.xba.median(),'a_d_good':True,'tab_name':'xBA'},
+ 'xslg':{'format':':.3f','average':df_median.xslg.median(),'a_d_good':True,'tab_name':'xSLG'},
+ 'woba':{'format':':.3f','average':df_median.woba.median(),'a_d_good':True,'tab_name':'wOBA'},
+ 'xwoba':{'format':':.3f','average':df_median.xwoba.median(),'a_d_good':True,'tab_name':'xwOBA'},
+ 'xobp':{'format':':.3f','average':df_median.xobp.median(),'a_d_good':True,'tab_name':'xOBP'},
+ 'xiso':{'format':':.3f','average':df_median.xiso.median(),'a_d_good':True,'tab_name':'xISO'},
+ 'wobacon':{'format':':.3f','average':df_median.wobacon.median(),'a_d_good':True,'tab_name':'wOBACON'},
+ 'xwobacon':{'format':':.3f','average':df_median.xwobacon.median(),'a_d_good':True,'tab_name':'xwOBACON'},
+ 'bacon':{'format':':.1f','average':df_median.bacon.median(),'a_d_good':True,'tab_name':'BACON'},
+ 'xbacon':{'format':':.1f','average':df_median.xbacon.median(),'a_d_good':True,'tab_name':'xBACON'},
+ 'xbadiff':{'format':':.3f','average':df_median.xbadiff.median(),'a_d_good':True,'tab_name':'BA-xBA'},
+ 'xslgdiff':{'format':':.3f','average':df_median.xslgdiff.median(),'a_d_good':True,'tab_name':'SLG-xSLG'},
+ 'wobadiff':{'format':':.3f','average':df_median.wobadiff.median(),'a_d_good':True,'tab_name':'wOBA-xwOBA'},
+ 'exit_velocity_avg':{'format':':.1f','average':(df.exit_velocity_avg * df.batted_ball).sum() / (df.batted_ball).sum(),'a_d_good':True,'tab_name':'EV'},
+ 'launch_angle_avg':{'format':':.1f','average':(df.launch_angle_avg * df.batted_ball).sum() / (df.batted_ball).sum(),'a_d_good':True,'tab_name':'LA'},
+ 'barrel':{'format':':.0f','average':df_median.barrel.median(),'a_d_good':True,'tab_name':'Barrel'},
+ 'barrel_batted_rate':{'format':':.1%','average':(df.barrel).sum() / (df.batted_ball).sum(),'a_d_good':True,'tab_name':'Barrel%'},
+ 'avg_best_speed':{'format':':.1f','average':(df.avg_best_speed * df.batted_ball).sum() / (df.batted_ball).sum(),'a_d_good':True,'tab_name':'Best Speed'},
+ 'avg_hyper_speed':{'format':':.1f','average':(df.avg_hyper_speed * df.batted_ball).sum() / (df.batted_ball).sum(),'a_d_good':True,'tab_name':'Hyper Speed'},
+ 'out_zone_swing_miss':{'format':':.0f','average':df_median.out_zone_swing_miss.mean(),'a_d_good':True,'tab_name':'O-Whiff%'},
+ 'out_zone_swing':{'format':':.0f','average':df_median.out_zone_swing.mean(),'a_d_good':True,'tab_name':'O-Swing'},
+ 'out_zone':{'format':':.0f','average':df_median.out_zone.mean(),'a_d_good':True,'tab_name':'O-Zone'},
+ 'pitch_count_offspeed':{'format':':.0f','average':df_median.pitch_count_offspeed.mean(),'a_d_good':True,'tab_name':'Pitch Off-Speed'},
+ 'pitch_count_fastball':{'format':':.0f','average':df_median.pitch_count_fastball.mean(),'a_d_good':True,'tab_name':'Pitch Fastball'},
+ 'pitch_count_breaking':{'format':':.0f','average':df_median.pitch_count_breaking.mean(),'a_d_good':True,'tab_name':'Pitch Breaking'},
+ 'pitch_count':{'format':':.0f','average':df_median.pitch_count.mean(),'a_d_good':True,'tab_name':'Pitches'},
+ 'in_zone_swing_miss':{'format':':.0f','average':df_median.in_zone_swing_miss.mean(),'a_d_good':False,'tab_name':'Z-Whiff'},
+ 'in_zone_swing':{'format':':.0f','average':df_median.in_zone_swing.mean(),'a_d_good':True,'tab_name':'Z-Swing'},
+ 'in_zone':{'format':':.0f','average':df_median.in_zone.mean(),'a_d_good':True,'tab_name':'Zone'},
+ 'edge':{'format':':.0f','average':df_median.edge.mean(),'a_d_good':True,'tab_name':'Edge'},
+ 'batted_ball':{'format':':.0f','average':df_median.batted_ball.mean(),'a_d_good':True,'tab_name':'Batted Balls'},
+ 'groundballs':{'format':':.0f','average':df_median.groundballs.mean(),'a_d_good':True,'tab_name':'Groundballs'},
+ 'flyballs':{'format':':.0f','average':df_median.flyballs.mean(),'a_d_good':True,'tab_name':'Flyballs'},
+ 'linedrives':{'format':':.0f','average':df_median.linedrives.mean(),'a_d_good':True,'tab_name':'Linedrives'},
+ 'popups':{'format':':.0f','average':df_median.popups.mean(),'a_d_good':True,'tab_name':'Popups'},
+ 'n_bolts':{'format':':.0f','average':df_median.n_bolts.mean(),'a_d_good':True,'tab_name':'Bolts'},
+ 'hp_to_1b':{'format':':.2f','average':df_median.hp_to_1b.mean(),'a_d_good':True,'tab_name':'Home Plate to 1st'},
+ 'sprint_speed':{'format':':.1f','average':df_median.sprint_speed.mean(),'a_d_good':True,'tab_name':'Sprint Speed'},
+
+ 'slg_percent':{'format':':.1%','average':(df.single.sum() + df.double.sum()*2 + df.triple.sum()*3 + df.home_run.sum()*4)/df.ab.sum(),'a_d_good':True,'tab_name':'SLG'},
+ 'on_base_percent':{'format':':.1%','average':df_median.on_base_percent.median(),'a_d_good':True,'tab_name':'OBP'},
+ 'sweet_spot_percent':{'format':':.1%','average':df_median.sweet_spot_percent.median(),'a_d_good':True,'tab_name':'SweetSpot%'},
+ 'solidcontact_percent':{'format':':.1%','average':df_median.solidcontact_percent.median(),'a_d_good':True,'tab_name':'Solid%'},
+ 'flareburner_percent':{'format':':.1%','average':df_median.flareburner_percent.median(),'a_d_good':False,'tab_name':'Flare/Burner%'},
+ 'poorlyunder_percent':{'format':':.1%','average':df_median.poorlyunder_percent.median(),'a_d_good':False,'tab_name':'Under%'},
+ 'poorlytopped_percent':{'format':':.1%','average':df_median.poorlytopped_percent.median(),'a_d_good':False,'tab_name':'Topped%'},
+ 'poorlyweak_percent':{'format':':.1%','average':df_median.poorlyweak_percent.median(),'a_d_good':False,'tab_name':'Weak%'},
+ 'hard_hit_percent':{'format':':.1%','average':df_median.hard_hit_percent.median(),'a_d_good':True,'tab_name':'HardHit%'},
+ 'z_swing_percent':{'format':':.1%','average':df.in_zone_swing.sum()/df.in_zone.sum(),'a_d_good':True,'tab_name':'Z-Swing%'},
+ 'z_swing_miss_percent':{'format':':.1%','average':df.in_zone_swing_miss.sum()/df.in_zone_swing.sum(),'a_d_good':False,'tab_name':'Z-Whiff%'},
+
+ 'out_zone_percent':{'format':':.1%','average':df.out_zone.sum()/df.pitch_count.sum(),'a_d_good':True,'tab_name':'O-Zone%'},
+ 'meatball_swing_percent':{'format':':.1%','average':df_median.meatball_swing_percent.median(),'a_d_good':True,'tab_name':'Meatball Swing%'},
+ 'meatball_percent':{'format':':.1%','average':df_median.meatball_percent.median(),'a_d_good':True,'tab_name':'Meatball%'},
+ 'iz_contact_percent':{'format':':.1%','average':1 - df.in_zone_swing_miss.sum()/df.in_zone_swing.sum(),'a_d_good':True,'tab_name':'Z-Contact%'},
+ 'in_zone_percent':{'format':':.1%','average':df.in_zone.mean()/df.pitch_count.sum(),'a_d_good':True,'tab_name':'Zone%'},
+ 'oz_swing_percent':{'format':':.1%','average':df.out_zone_swing.sum()/df.out_zone.sum(),'a_d_good':False,'tab_name':'O-Swing%'},
+ 'oz_swing_miss_percent':{'format':':.1%','average':df.out_zone_swing_miss.sum()/df.out_zone_swing.sum(),'a_d_good':False,'tab_name':'O-Whiff%'},
+ 'oz_contact_percent':{'format':':.1%','average':1 - df.out_zone_swing_miss.sum()/df.out_zone_swing.sum(),'a_d_good':True,'tab_name':'O-Contact%'},
+ 'edge_percent':{'format':':.1%','average':df_median.edge_percent.median(),'a_d_good':True,'tab_name':'Edge%'},
+ 'whiff_percent':{'format':':.1%','average':(df.in_zone_swing_miss.sum() + df.out_zone_swing_miss.sum()) / (df.in_zone_swing.sum() + df.out_zone_swing.sum()),'a_d_good':False,'tab_name':'Whiff%'},
+ 'swstr_percent':{'format':':.1%','average':(df.in_zone_swing_miss.sum() + df.out_zone_swing_miss.sum()) / (df.pitch_count.sum()),'a_d_good':False,'tab_name':'SwStr%'},
+ 'swing_percent':{'format':':.1%','average':(df.in_zone_swing.sum() + df.out_zone_swing.sum()) / (df.pitch_count.sum()),'a_d_good':True,'tab_name':'Swing%'},
+ 'pull_percent':{'format':':.1%','average':df_median.hit.median(),'a_d_good':True,'tab_name':'Pull%'},
+ 'straightaway_percent':{'format':':.1%','average':df_median.hit.median(),'a_d_good':True,'tab_name':'Straightaway%'},
+ 'opposite_percent':{'format':':.1%','average':df_median.hit.median(),'a_d_good':True,'tab_name':'Opposite%'},
+ 'f_strike_percent':{'format':':.1%','average':df_median.hit.median(),'a_d_good':False,'tab_name':'1st Strike%'},
+ 'groundballs_percent':{'format':':.1%','average':df.groundballs.sum()/df.batted_ball.sum(),'a_d_good':False,'tab_name':'GB%'},
+ 'flyballs_percent':{'format':':.1%','average':df.flyballs.sum()/df.batted_ball.sum(),'a_d_good':True,'tab_name':'FB%'},
+ 'linedrives_percent':{'format':':.1%','average':df.linedrives.sum()/df.batted_ball.sum(),'a_d_good':True,'tab_name':'LD%'},
+ 'popups_percent':{'format':':.1%','average':df.popups.sum()/df.batted_ball.sum(),'a_d_good':False,'tab_name':'PU%'},}
+
+column_dict = pd.DataFrame(format_dict.keys(),[format_dict[x]['tab_name'] for x in format_dict.keys()]).reset_index().set_index(0).to_dict()['index']
+
+
+def server(input,output,session):
+
+
+    @output
+    @render.text
+    @reactive.event(input.go, ignore_none=False)    
+    def txt_title():
+        if input.player_id() == '':
+            return 'Select a Player'
+
+        player_input = int(input.player_id())
+        season_1 = max(2015,int(input.season_1()))
+        season_2 = min(2023,int(input.season_2()))
+
+        if season_1 < season_2:
+            season_pick = [season_1,season_2]
+
+        elif season_1 > season_2:
+            season_pick = [season_2,season_1]
+
+        if len(str(input.player_id())) == 0:
+            return 'Select a Batter'
+        if str(input.season_1()) == str(input.season_2()):
+            return 'Select Different Seasons'
+        if len(df[(df.player_id == player_input)&(df.year == season_pick[0])] )== 0 or len(df[(df.player_id == player_input)&(df.year == season_pick[1])] )== 0:
+            return 'Select Different Seasons'
+        return   f'{player_dict[int(input.player_id())]} Statcast Season Comparison'
+
+    @output
+    @render.text
+    @reactive.event(input.go, ignore_none=False)    
+    def txt_title_compare():
+        if type(input.player_id()) is int or input.player_id()=='':
+            return
+
+        if type(input.player_id_2()) is int or input.player_id_2()=='':
+            return    
+
+        player_input_1 = int(input.player_id())
+        player_input_2 = int(input.player_id_2())
+
+
+        # season_pick = [input.season_1(),input.season_2()]
+        columns_i_want = list(input.row_select())
+        print(columns_i_want)
+        season_1 = max(2015,int(input.season_1()))
+        season_2 = min(2023,int(input.season_2()))
+
+        player_list = [player_input_1,player_input_2]
+        name_list = [player_dict[int(player_input_1)],player_dict[int(player_input_2)]]
+        season_pick_list = [season_1,season_2]
+
+        if len(str(input.player_id())) == 0:
+            return 'Select a Batter'
+        if len(str(input.player_id_2())) == 0:
+            return 'Select a Batter'
+
+        if str(input.player_id()) == str(input.player_id_2()) and str(input.season_1()) == str(input.season_2()):
+            return 'Select Different Seasons'
+        if len(df[(df.player_id == player_list[0])&(df.year == season_pick_list[0])] )== 0 or len(df[(df.player_id == player_list[1])&(df.year == season_pick_list[1])])== 0:
+            return 'No Data for Specified Batter in Given Season'
+        
+        return   f'Statcast Season Comparison'
+
+
+
+
+    @output
+    @render.text
+    @reactive.event(input.go, ignore_none=False)
+    def text_2022():
+        if input.player_id() == '':
+            return 'Select a Player'
+        return   f'{int(input.season_1())} Season Results Compares to MLB Average'
+
+
+    @output
+    @render.text
+    @reactive.event(input.go, ignore_none=False)
+    def text_2022_1():
+        if type(input.player_id()) is int or input.player_id()=='':
+            return
+
+        if type(input.player_id_2()) is int or input.player_id_2()=='':
+            return     
+        season_1 = max(2015,int(input.season_1()))
+        season_2 = min(2023,int(input.season_2()))
+        season_pick_list = [season_1,season_2]
+        player_input_1 = int(input.player_id())
+        player_input_2 = int(input.player_id_2())
+        name_list = [player_dict[int(player_input_1)],player_dict[int(player_input_2)]]
+        return   f"{name_list[0]} '{str(season_pick_list[0])[2:]} Season Results Compares to MLB Average"
+
+    @output
+    @render.text
+    @reactive.event(input.go, ignore_none=False)
+    def text_2023():
+        if input.player_id() == '':
+            return 'Select a Player'
+        return   f'{int(input.season_2())} Season Results Compares to MLB Average'
+
+    @output
+    @render.text
+    @reactive.event(input.go, ignore_none=False)
+    def text_2023_1():
+        if type(input.player_id()) is int or input.player_id()=='':
+            return
+
+        if type(input.player_id_2()) is int or input.player_id_2()=='':
+            return    
+        season_1 = max(2015,int(input.season_1()))
+        season_2 = min(2023,int(input.season_2()))
+        season_pick_list = [season_1,season_2]
+        player_input_1 = int(input.player_id())
+        player_input_2 = int(input.player_id_2())
+        name_list = [player_dict[int(player_input_1)],player_dict[int(player_input_2)]]
+        return   f"{name_list[1]} '{str(season_pick_list[1])[2:]} Season Results Compares to MLB Average"
+
+    @output
+    @render.text
+    @reactive.event(input.go, ignore_none=False)
+    def text_diff():
+        if input.player_id() == '':
+            return 'Select a Player'
+        return   f'Difference Compares {int(input.season_2())} Results to {int(input.season_1())} Results'
+
+    @output
+    @render.text
+    @reactive.event(input.go, ignore_none=False)
+    def text_diff_compare():
+        if type(input.player_id()) is int or input.player_id()=='':
+            return
+
+        if type(input.player_id_2()) is int or input.player_id_2()=='':
+            return    
+        player_input_1 = int(input.player_id())
+        player_input_2 = int(input.player_id_2())
+        name_list = [player_dict[int(player_input_1)],player_dict[int(player_input_2)]]
+        return   f'Difference Compares {name_list[0]} Results to {name_list[1]} Results'
+
+
+
+    @output
+    @render.table
+    @reactive.event(input.go, ignore_none=False)
+    def statcast_compare():
+        if input.player_id() == '':
+            return
+
+        if len(str(input.player_id())) == 0:
+            return
+        if len(str(input.player_id_2())) == 0:
+            return
+
+
+        player_input = int(input.player_id())
+
+
+        # season_pick = [input.season_1(),input.season_2()]
+        columns_i_want = list(input.row_select())
+        print(columns_i_want)
+        season_1 = max(2015,int(input.season_1()))
+        season_2 = min(2023,int(input.season_2()))
+
+
+        if season_1 < season_2:
+            season_pick = [season_1,season_2]
+
+        elif season_1 > season_2:
+            season_pick = [season_2,season_1]
+
+        else:
+            return
+
+        print(df[(df.player_id == player_input)&(df.year == season_pick[0])])
+    
+
+        if len(df[(df.player_id == player_input)&(df.year == season_pick[0])] )== 0 or len(df[(df.player_id == player_input)&(df.year == season_pick[1])] )== 0:
+            return
+
+        df_compare = pd.concat([df[(df.player_id == player_input)&(df.year == season_pick[0])][[ 'player_age', 'pa']+columns_i_want],
+                                df[(df.player_id == player_input)&(df.year == season_pick[1])][[ 'player_age', 'pa']+columns_i_want]]).reset_index(drop=True).T
+
+
+        print('test')
+        print(sum(df.player_id == input.player_id()))
+        df_compare.columns = season_pick
+
+        df_compare['Difference'] = df_compare.loc[columns_i_want][season_pick[1]] - df_compare.loc[columns_i_want][season_pick[0]]
+
+        df_compare_style = df_compare.style.format(
+                    "{:.0f}")
+        df_compare_style = df_compare_style.set_properties(**{'background-color': 'white',
+                                'color': 'white'},subset=(['player_age', 'pa'],df_compare_style.columns[2])).set_properties(
+                    **{'min-width':'100px'},overwrite=False).set_table_styles(
+            [{'selector': 'th:first-child', 'text-align': 'center','props': [('background-color', 'white')]}],overwrite=False).set_table_styles(
+            [{'selector': 'tr:first-child','text-align': 'center', 'props': [('background-color', 'white')]}],overwrite=False).set_table_styles(
+            [{'selector': 'index','text-align': 'center', 'props': [('background-color', 'white')]}],overwrite=False).set_table_styles(
+            [{'selector': 'th', 'text-align': 'center','props': [('line-height', '40px'),('min-width', '30px')]}],overwrite=False).set_properties(
+                
+            **{'Height': '20px'},**{'text-align': 'center'},overwrite=False).set_table_styles([{
+            'selector': 'caption',
+            'props': [
+                ('color', ''),
+                ('fontname', 'Century Gothic'),
+                ('font-size', '20px'),
+                ('font-style', 'italic'),
+                ('font-weight', ''),
+                ('text-align', 'centre'),
+                ]
+
+                },{'selector' :'th', 'props':[('text-align', 'center'),('font-size', '20px'),('Height','20px'),('min-width','200px')]},{'selector' :'td', 'props':[('text-align', 'center'),('font-size', '20px'),('min-width','100px')]}],overwrite=False)
+
+
+        for r in columns_i_want:
+            if format_dict[r]['a_d_good']:
+                cmap = matplotlib.colors.LinearSegmentedColormap.from_list("", ["#4285F4","white","#FBBC04"])
+            else:
+                cmap = matplotlib.colors.LinearSegmentedColormap.from_list("", ["#FBBC04","white","#4285F4"])
+
+
+            colormap = plt.get_cmap(cmap)
+            norm = Normalize(vmin=0.7, vmax=1.3)
+
+            normalized_value = norm(df_compare[df_compare.columns[0]][r]/format_dict[r]['average'])
+            df_compare_style.format(
+                    f"{{{format_dict[r]['format']}}}",subset=(r,df_compare_style.columns[0])).set_properties(**{'background-color': '#%02x%02x%02x' % (int(colormap(normalized_value)[0] *255), int(colormap(normalized_value)[1] *255), int(colormap(normalized_value)[2] *255)),
+                                'color': 'black'},subset=(r,df_compare_style.columns[0]))
+
+            norm = Normalize(vmin=0.7, vmax=1.3)
+            normalized_value = norm(df_compare[df_compare.columns[1]][r]/format_dict[r]['average'])
+            df_compare_style.format(
+                    f"{{{format_dict[r]['format']}}}",subset=(r,df_compare_style.columns[1])).set_properties(**{'background-color': '#%02x%02x%02x' % (int(colormap(normalized_value)[0] *255), int(colormap(normalized_value)[1] *255), int(colormap(normalized_value)[2] *255)),
+                                'color': 'black'},subset=(r,df_compare_style.columns[1]))
+
+            norm = Normalize(vmin=0.7, vmax=1.3)
+            normalized_value = norm(df_compare[df_compare.columns[1]][r]/df_compare[df_compare.columns[0]][r])
+            df_compare_style.format(
+                    f"{{{format_dict[r]['format']}}}",subset=(r,df_compare_style.columns[2])).set_properties(**{'background-color': '#%02x%02x%02x' % (int(colormap(normalized_value)[0] *255), int(colormap(normalized_value)[1] *255), int(colormap(normalized_value)[2] *255)),
+                                'color': 'black'},subset=(r,df_compare_style.columns[2]))
+
+
+
+
+        df_compare_style.relabel_index(['Age', 'PA']+[format_dict[x]['tab_name'] for x in columns_i_want]).set_properties(
+                    **{'border': '1px black solid !important'},overwrite=False).set_table_styles(
+            [{"selector": "", "props": [("border", "1px solid")]},
+            {"selector": "tbody td", "props": [("border", "1px solid")]},
+            {"selector": "th", "props": [("border", "1px solid")]}],overwrite=False)
+
+        #df_compare = df_compare.fillna(np.nan)     
+
+        return df_compare_style
+
+
+
+    @output
+    @render.table
+    @reactive.event(input.go, ignore_none=False)
+    def statcast_compare_2():
+
+        # if input.player_id() == 0:
+        #     return
+        if type(input.player_id()) is int or input.player_id()=='':
+            return
+
+        if type(input.player_id_2()) is int or input.player_id_2()=='':
+            return      
+        # if len(str(input.player_id())) == 0:
+        #     return
+
+        player_input_1 = int(input.player_id())
+        player_input_2 = int(input.player_id_2())
+
+
+        # season_pick = [input.season_1(),input.season_2()]
+        columns_i_want = list(input.row_select())
+        print(columns_i_want)
+        season_1 = max(2015,int(input.season_1()))
+        season_2 = min(2023,int(input.season_2()))
+
+
+        # if season_1 < season_2:
+        #     season_pick = [season_1,season_2]
+
+        # elif season_1 > season_2:
+        #     season_pick = [season_2,season_1]
+
+        # else:
+        #     return
+
+        #print(df[(df.player_id == player_input)&(df.year == season_pick[0])])
+        #player_list = ['Elly De La Cruz','Aaron Judge']
+        player_list = [player_input_1,player_input_2]
+        name_list = [player_dict[int(player_input_1)],player_dict[int(player_input_2)]]
+        season_pick_list = [season_1,season_2]
+
+        if len(df[(df.player_id == player_list[0])&(df.year == season_pick_list[0])] )== 0 or len(df[(df.player_id == player_list[1])&(df.year == season_pick_list[1])] )== 0:
+            return
+        if str(input.player_id()) == str(input.player_id_2()) and str(input.season_1()) == str(input.season_2()):
+            return
+
+
+        df_compare = pd.concat([df[(df.player_id == player_list[0])&(df.year == season_pick_list[0])][[ 'year','player_age', 'pa']+columns_i_want],
+        df[(df.player_id == player_list[1])&(df.year == season_pick_list[1])][[ 'year','player_age', 'pa']+columns_i_want]]).reset_index(drop=True).T
+
+        df_compare.columns = [f"{name_list[0]} '{str(season_pick_list[0])[2:]}",f"{name_list[1]} '{str(season_pick_list[1])[2:]}"]
+        df_compare['Difference'] = df_compare.loc[columns_i_want][df_compare.columns [0]] - df_compare.loc[columns_i_want][df_compare.columns[1]]
+        #df_compare = df_compare.fillna(np.nan)
+
+        df_compare_style = df_compare.style.format(
+                    "{:.0f}")
+        df_compare_style = df_compare_style.set_properties(**{'background-color': 'white',
+                                'color': 'white'},subset=(['year','player_age', 'pa'],df_compare_style.columns[2])).set_properties(
+                    **{'min-width':'125px'},overwrite=False).set_table_styles(
+            [{'selector': 'th:first-child', 'text-align': 'center','props': [('background-color', 'white')]}],overwrite=False).set_table_styles(
+            [{'selector': 'tr:first-child','text-align': 'center', 'props': [('background-color', 'white')]}],overwrite=False).set_table_styles(
+            [{'selector': 'index','text-align': 'center', 'props': [('background-color', 'white')]}],overwrite=False).set_table_styles(
+            [{'selector': 'th', 'text-align': 'center','props': [('line-height', '40px'),('min-width', '30px')]}],overwrite=False).set_properties(
+                
+            **{'Height': '20px'},**{'text-align': 'center'},overwrite=False).set_table_styles([{
+            'selector': 'caption',
+            'props': [
+                ('color', ''),
+                ('fontname', 'Century Gothic'),
+                ('font-size', '20px'),
+                ('font-style', 'italic'),
+                ('font-weight', ''),
+                ('text-align', 'centre'),
+                ]
+
+                },{'selector' :'th', 'props':[('text-align', 'center'),('font-size', '20px'),('Height','20px'),('min-width','200px')]},{'selector' :'td', 'props':[('text-align', 'center'),('font-size', '20px'),('min-width','100px')]}],overwrite=False)
+
+
+        for r in columns_i_want:
+            if format_dict[r]['a_d_good']:
+                cmap = matplotlib.colors.LinearSegmentedColormap.from_list("", ["#4285F4","white","#FBBC04"])
+            else:
+                cmap = matplotlib.colors.LinearSegmentedColormap.from_list("", ["#FBBC04","white","#4285F4"])
+
+
+            colormap = plt.get_cmap(cmap)
+            norm = Normalize(vmin=0.5, vmax=1.5)
+            normalized_value = norm(df_compare[df_compare.columns[0]][r]/format_dict[r]['average'])
+            df_compare_style.format(
+                    f"{{{format_dict[r]['format']}}}",subset=(r,df_compare_style.columns[0])).set_properties(**{'background-color': '#%02x%02x%02x' % (int(colormap(normalized_value)[0] *255), int(colormap(normalized_value)[1] *255), int(colormap(normalized_value)[2] *255)),
+                                'color': 'black'},subset=(r,df_compare_style.columns[0]))
+
+            norm = Normalize(vmin=0.5, vmax=1.5)
+            normalized_value = norm(df_compare[df_compare.columns[1]][r]/format_dict[r]['average'])
+            df_compare_style.format(
+                    f"{{{format_dict[r]['format']}}}",subset=(r,df_compare_style.columns[1])).set_properties(**{'background-color': '#%02x%02x%02x' % (int(colormap(normalized_value)[0] *255), int(colormap(normalized_value)[1] *255), int(colormap(normalized_value)[2] *255)),
+                                'color': 'black'},subset=(r,df_compare_style.columns[1]))
+
+            norm = Normalize(vmin=0.8, vmax=1.2)
+            normalized_value = norm(df_compare[df_compare.columns[0]][r]/df_compare[df_compare.columns[1]][r])
+            df_compare_style.format(
+                    f"{{{format_dict[r]['format']}}}",subset=(r,df_compare_style.columns[2])).set_properties(**{'background-color': '#%02x%02x%02x' % (int(colormap(normalized_value)[0] *255), int(colormap(normalized_value)[1] *255), int(colormap(normalized_value)[2] *255)),
+                                'color': 'black'},subset=(r,df_compare_style.columns[2]))
+
+        df_compare_style = df_compare_style
+
+
+        df_compare_style.relabel_index(['Year','Age', 'PA']+[format_dict[x]['tab_name'] for x in columns_i_want]).set_properties(
+                    **{'border': '1px black solid !important'},overwrite=False).set_table_styles(
+            [{"selector": "", "props": [("border", "1px solid")]},
+            {"selector": "tbody td", "props": [("border", "1px solid")]},
+            {"selector": "th", "props": [("border", "1px solid")]}],overwrite=False)
+
+        #df_compare = df_compare.fillna(np.nan)     
+
+        return df_compare_style
+
+    @output
+    @render.table
+    @reactive.event(input.go, ignore_none=False)
+    def colour_scale():
+        off_b2b_df = pd.DataFrame(data={'one':-0.30,'two':0,'three':0.30},index=[0])
+        off_b2b_df_style = off_b2b_df.style.set_properties(**{'border': '3 px'},overwrite=False).set_table_styles([{
+            'selector': 'caption',
+            'props': [
+                ('color', ''),
+                ('fontname', 'Century Gothic'),
+                ('font-size', '20px'),
+                ('font-style', 'italic'),
+                ('font-weight', ''),
+                ('text-align', 'centre'),
+                ]
+
+                },{'selector' :'th', 'props':[('text-align', 'center'),('Height','px'),('color','black'),(
+                    'border', '1px black solid !important')]},{'selector' :'td', 'props':[('text-align', 'center'),('font-size', '18px'),('color','black')]}],overwrite=False).set_properties(
+                    **{'background-color':'White','index':'White','min-width':'150px'},overwrite=False).set_table_styles(
+            [{'selector': 'th:first-child', 'props': [('background-color', 'white')]}],overwrite=False).set_table_styles(
+            [{'selector': 'tr:first-child', 'props': [('background-color', 'white')]}],overwrite=False).set_table_styles(
+            [{'selector': 'tr', 'props': [('line-height', '20px')]}],overwrite=False).set_properties(
+            **{'Height': '8px'},**{'text-align': 'center'},overwrite=False).set_properties(
+                **{'background-color':'#4285F4'},subset=off_b2b_df.columns[0]).set_properties(
+                **{'background-color':'white'},subset=off_b2b_df.columns[1]).set_properties(
+                **{'background-color':'#FBBC04'},subset=off_b2b_df.columns[2]).set_properties(
+                **{'color':'black'},subset=off_b2b_df.columns[:]).hide_index().set_table_styles([
+            {'selector': 'thead', 'props': [('display', 'none')]}
+            ]).set_properties(**{'border': '3 px','color':'black'},overwrite=False).set_properties(
+                    **{'border': '1px black solid !important'},subset = ((list(off_b2b_df.index[:]),off_b2b_df.columns[:]))).set_properties(
+                    **{'min-width':'130'},subset = ((list(off_b2b_df.index[:]),off_b2b_df.columns[:])),overwrite=False).set_properties(**{
+                                'color': 'black'},overwrite=False).set_properties(
+                    **{'border': '1px black solid !important'},subset = ((list(off_b2b_df.index[:]),off_b2b_df.columns[:]))) .format(
+                    "{:+.0%}")
+        return off_b2b_df_style
+
+    @output
+    @render.table
+    @reactive.event(input.go, ignore_none=False)
+    def colour_scale_2():
+        off_b2b_df = pd.DataFrame(data={'one':-0.30,'two':0,'three':0.30},index=[0])
+        off_b2b_df_style = off_b2b_df.style.set_properties(**{'border': '3 px'},overwrite=False).set_table_styles([{
+            'selector': 'caption',
+            'props': [
+                ('color', ''),
+                ('fontname', 'Century Gothic'),
+                ('font-size', '20px'),
+                ('font-style', 'italic'),
+                ('font-weight', ''),
+                ('text-align', 'centre'),
+                ]
+
+                },{'selector' :'th', 'props':[('text-align', 'center'),('Height','px'),('color','black'),(
+                    'border', '1px black solid !important')]},{'selector' :'td', 'props':[('text-align', 'center'),('font-size', '18px'),('color','black')]}],overwrite=False).set_properties(
+                    **{'background-color':'White','index':'White','min-width':'150px'},overwrite=False).set_table_styles(
+            [{'selector': 'th:first-child', 'props': [('background-color', 'white')]}],overwrite=False).set_table_styles(
+            [{'selector': 'tr:first-child', 'props': [('background-color', 'white')]}],overwrite=False).set_table_styles(
+            [{'selector': 'tr', 'props': [('line-height', '20px')]}],overwrite=False).set_properties(
+            **{'Height': '8px'},**{'text-align': 'center'},overwrite=False).set_properties(
+                **{'background-color':'#4285F4'},subset=off_b2b_df.columns[0]).set_properties(
+                **{'background-color':'white'},subset=off_b2b_df.columns[1]).set_properties(
+                **{'background-color':'#FBBC04'},subset=off_b2b_df.columns[2]).set_properties(
+                **{'color':'black'},subset=off_b2b_df.columns[:]).hide_index().set_table_styles([
+            {'selector': 'thead', 'props': [('display', 'none')]}
+            ]).set_properties(**{'border': '3 px','color':'black'},overwrite=False).set_properties(
+                    **{'border': '1px black solid !important'},subset = ((list(off_b2b_df.index[:]),off_b2b_df.columns[:]))).set_properties(
+                    **{'min-width':'130'},subset = ((list(off_b2b_df.index[:]),off_b2b_df.columns[:])),overwrite=False).set_properties(**{
+                                'color': 'black'},overwrite=False).set_properties(
+                    **{'border': '1px black solid !important'},subset = ((list(off_b2b_df.index[:]),off_b2b_df.columns[:]))) .format(
+                    "{:+.0%}")
+
+
+        return off_b2b_df_style
+# test = test.fillna(0)
+#test['PP TOI'] = ["%d:%02d" % (int(x),(x*60)%60) if x>0 else '0:00' for x in test['PP TOI']]
+
+
+app = App(ui.page_fluid(
+#    ui.tags.base(href=base_url),
+    ui.tags.div(
+         {"style": "width:90%;margin: 0 auto;max-width: 1600px;"},
+        ui.tags.style(
+            """
+            h4 {
+                margin-top: 1em;font-size:35px;
+            }
+            h2{
+                font-size:25px;
+            }
+            """
+         ),
+    shinyswatch.theme.simplex(),
+    ui.tags.h4("TJStats"),
+    ui.tags.i("Baseball Analytics and Visualizations"),
+    ui.markdown("""<a href='https://www.patreon.com/tj_stats'>Support me on Patreon for Access to 2024 Apps</a><sup>1</sup>"""),
+
+    ui.navset_tab(
+        ui.nav_control(
+             ui.a(
+                "Home",
+                href="https://nesticot-tjstats-site.hf.space/home/"
+            ),
+        ),
+        ui.nav_menu(
+            "Batter Charts",
+            ui.nav_control(
+            ui.a(
+                "Batting Rolling",
+                href="https://nesticot-tjstats-site-rolling-batter.hf.space/"
+            ),
+            ui.a(
+                "Spray",
+                href="https://nesticot-tjstats-site-spray.hf.space/"
+            ),
+            ui.a(
+                "Decision Value",
+                href="https://nesticot-tjstats-site-decision-value.hf.space/"
+            ),
+            ui.a(
+                "Damage Model",
+                href="https://nesticot-tjstats-site-damage.hf.space/"
+            ),
+            ui.a(
+                "Batter Scatter",
+                href="https://nesticot-tjstats-site-batter-scatter.hf.space/"
+            ),
+            ui.a(
+                "EV vs LA Plot",
+                href="https://nesticot-tjstats-site-ev-angle.hf.space/"
+            ),
+            ui.a(
+                "Statcast Compare",
+                href="https://nesticot-tjstats-site-statcast-compare.hf.space/"
+            ),
+            ui.a(
+                "MLB/MiLB Cards",
+                href="https://nesticot-tjstats-site-mlb-cards.hf.space/"
+            )
+        ),
+        ),
+        ui.nav_menu(
+            "Pitcher Charts",
+            ui.nav_control(
+             ui.a(
+                "Pitcher Rolling",
+                href="https://nesticot-tjstats-site-rolling-pitcher.hf.space/"
+            ),
+             ui.a(
+                "Pitcher Summary",
+                href="https://nesticot-tjstats-site-pitching-summary-graphic-new.hf.space/"
+            ),
+             ui.a(
+                "Pitcher Scatter",
+                href="https://nesticot-tjstats-site-pitcher-scatter.hf.space"
+            )
+        ),
+        )), ui.row(
+    ui.layout_sidebar(
+        
+   
+
+      ui.panel_sidebar(
+        #ui.input_date_range("date_range_id", "Date range input",start = statcast_df.game_date.min(), end = statcast_df.game_date.max()),
+        ui.input_select("player_id", "Select Player 1",player_dict,width=1,size=1,selectize=True,multiple=False,selected=592450),
+        ui.input_select("player_id_2", "Select Player 2 (For Player Compare Tab)",player_dict,width=1,size=1,selectize=True,multiple=False,selected=592450),
+        ui.input_numeric("season_1", "Season 1", value=2022,min=2015,max=2023),
+        ui.input_numeric("season_2", "Season 2", value=2023,min=2015,max=2023),
+        ui.input_select("row_select", "Select Stats",
+                        column_dict,width=1,size=1,selectize=True,
+                        multiple=True,
+                        selected=['k_percent','bb_percent','woba','xwoba','iz_contact_percent','oz_swing_percent','whiff_percent']),
+                ui.input_action_button("go", "Generate",class_="btn-primary",
+                                       )),
+
+        ui.panel_main(ui.tags.h3(""),
+            ui.navset_tab(
+                      ui.nav("Single Player",
+                        ui.div({"style": "font-size:2.1em;"},ui.output_text("txt_title")),
+                        #ui.tags.h2("Fantasy Hockey Schedule Summary"),
+                        ui.tags.h5("Created By: @TJStats,     Data: MLB"),
+                        #ui.div({"style": "font-size:1.6em;"},ui.output_text("txt")),
+                        ui.output_table("statcast_compare"),
+                        #ui.tags.h5('Legend'),
+                        ui.tags.h3(""),
+                        ui.tags.h5('Colour Scale:'),
+                        ui.output_table("colour_scale"),
+                        ui.div({"style": "font-size:1em;"},ui.output_text("text_2022")),
+                        ui.div({"style": "font-size:1em;"},ui.output_text("text_2023")),
+                        ui.div({"style": "font-size:1em;"},ui.output_text("text_diff"))),
+
+                    ui.nav("Player Compare",
+                        ui.div({"style": "font-size:2.1em;"},ui.output_text("txt_title_compare")),
+                        #ui.tags.h2("Fantasy Hockey Schedule Summary"),
+                        ui.tags.h5("Created By: @TJStats,     Data: MLB"),
+                        #ui.div({"style": "font-size:1.6em;"},ui.output_text("txt")),
+                        ui.output_table("statcast_compare_2"),
+                        ui.tags.h3(""),
+                        ui.tags.h5('Colour Scale:'),
+                        ui.output_table("colour_scale_2"),
+                        ui.div({"style": "font-size:1em;"},ui.output_text("text_2022_1")),
+                        ui.div({"style": "font-size:1em;"},ui.output_text("text_2023_1")),
+                        ui.div({"style": "font-size:1em;"},ui.output_text("text_diff_compare")))
+        )
+    ),
+    )),)),server)