Update app.py

app.py

@@ -1,494 +1,350 @@
-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 pitch_summary_functions as psf
+import requests
 import matplotlib
-from matplotlib.ticker import MaxNLocator
-from matplotlib.gridspec import GridSpec
-from scipy.stats import zscore
+from api_scraper import MLB_Scrape
 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
+
+season = 2024
+colour_palette = ['#FFB000','#648FFF','#785EF0',
+                  '#DC267F','#FE6100','#3D1EB2','#894D80','#16AA02','#B5592B','#A3C1ED']
+
+import datasets
+from datasets import load_dataset
+# from shiny import App, Inputs, Outputs, Session, reactive, render, req, ui
+from shiny import ui, render, App
+# ### Import Datasets
+# dataset = load_dataset('nesticot/mlb_data', data_files=[f'mlb_pitch_data_{season}.csv',
+#                                                         f'mlb_pitch_data_{season-1}.csv',
+#                                                          f'mlb_pitch_data_{season-2}.csv',
+#                                                           f'mlb_pitch_data_{season-3}.csv',
+#                                                            f'mlb_pitch_data_{season-4}.csv' ])
+
 
 ### Import Datasets
-dataset = load_dataset('nesticot/mlb_data', data_files=['mlb_pitch_data_2024.csv' ])
+dataset = load_dataset('nesticot/mlb_data', data_files=[f'aaa_pitch_data_{season}.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_2024 = dataset_train.to_pandas().set_index(list(dataset_train.features.keys())[0]).reset_index(drop=True).drop_duplicates(subset=['play_id'],keep='last')
+
+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'}
+
+print('MLB TOP',df_2024.head(5))
+
+import matplotlib.ticker as mtick
+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')
+    
+
+from batting_update import df_update, df_update_summ, df_update_summ_avg,df_summ_changes
 
-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)
-]
+df_2024_update_copy = df_update(df_2024)
+print('MLB TOP',df_2024_update_copy.head(5))
+from adjustText import adjust_text
+import seaborn as sns
 
-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'),
-    ]
+def server(input,output,session):
 
+    #@reactive.event(input.go, ignore_none=False)
 
-choices_woba = [1,
-                    1,
-                    1,
-                    2,
-                    3,
-                    4]
+    @output
+    @render.plot(alt="A histogram")    
+    def plot():
+        print('we made it here2')
+
+        start_date_input = '2024-03-20'
+        end_date_input = '2024-12-31'
+        df_2024_update = df_2024_update_copy[(df_2024_update_copy['game_date']>=start_date_input)&
+                                        (df_2024_update_copy['game_date']<=end_date_input)]
+        
+        df_2024_update_summ = df_update_summ(df_2024_update)
+        df_2024_update_summ_changes = df_summ_changes(df_2024_update_summ)
 
+        print('MLB TOP UPDATE ',df_2024_update_copy.head(5))
 
-# choices_woba = [0.698,
-#                     0.728,
-#                     0.887,
-#                     1.253,
-#                     1.583,
-#                     2.027]
+        sns.set_theme(style="whitegrid", palette="pastel")
+            
+        #print('we made it here')
+        #print(data_df)
+        #data_df = data_df.sort_values(by='level').reset_index(drop=True)
 
-df_2023['woba'] = np.select(conditions_woba, choices_woba, default=0)
 
-choices_woba_train = [1,
-                    1,
-                    1,
-                    2,
-                    3,
-                    4]
+        # x_flip = batter_dict_stat[x_stat]['flip_p']
+        # y_flip = batter_dict_stat[y_stat]['flip_p']
+        # cbr_flip = batter_dict_stat[z_stat]['flip_p']
 
-df_2023['woba_train'] = np.select(conditions_woba, choices_woba_train, default=0)
+        x_stat = 'whiff_rate'
+        y_stat = 'barrel_percent'
+        z_stat = 'woba_percent'
 
 
-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)
+        x_flip = batter_dict_stat[x_stat]['flip_p']
+        y_flip = batter_dict_stat[y_stat]['flip_p']
+        cbr_flip = batter_dict_stat[z_stat]['flip_p']
 
+        level_id = 'AAA'
+        n_input = 200
+        n_age_input = 50
 
-df_2023_bip['season'] = df_2023_bip['game_date'].str[0:4].astype(int)
+        data_df  = df_2024_update_summ.copy()
+        data_df = data_df[data_df['pa'] >= n_input].reset_index(drop=True)
 
-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'] == 2024]
+        data_df[x_stat+'_percent'] = data_df[x_stat].rank(pct=True,ascending=abs(x_flip-1))
 
-batter_dict = df_2023_bip.sort_values('batter_name').set_index('batter_id')['batter_name'].to_dict()
+        data_df[y_stat+'_percent'] = data_df[y_stat].rank(pct=True,ascending=abs(y_flip-1))
 
-features = ['launch_angle','launch_speed','h_la']
-target = ['woba_train']
+        data_df[z_stat+'_percent'] = data_df[z_stat].rank(pct=True,ascending=abs(cbr_flip-1))
 
-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')
 
+        fig, ax = plt.subplots(1, 1, figsize=(9, 9),dpi=300)
 
-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'))
+        if cbr_flip:
+            cmap_hue = matplotlib.colors.LinearSegmentedColormap.from_list("", [colour_palette[0],colour_palette[3],colour_palette[1]])
+            norm = plt.Normalize(data_df[z_stat].min(), data_df[z_stat].max())
 
-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)
+        else:
+            cmap_hue = matplotlib.colors.LinearSegmentedColormap.from_list("", [colour_palette[1],colour_palette[3],colour_palette[0]])
+            norm = plt.Normalize(data_df[z_stat].min(), data_df[z_stat].max())
 
-import pandas as pd
-import numpy as np
+        sm = plt.cm.ScalarMappable(cmap=cmap_hue, norm=norm)
+        print('we made it here')
 
+        scatter = sns.scatterplot(x = x_stat, y = y_stat, data=data_df, color = '#b3b3b3')    
+            #ax.get_legend().remove()
+        scatter = sns.scatterplot(x = x_stat, y = y_stat, data=data_df, color = colour_palette[0],ax=ax,hue=z_stat,palette=cmap_hue)
+        sns.set_theme(style="whitegrid", palette="pastel")
 
-# Create grid coordinates
-x = np.arange(30, 121,1 )
-y = np.arange(-30, 61,1 )
-z = np.arange(-45, 46,1 )
+        fig.set_facecolor('#F0F0F0')
+        ax.set_facecolor('white')
 
-# 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()
+        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)
 
-# 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
+        x_min = 0.2
+        x_max = 0.5
 
-colour_palette = ['#FFB000','#648FFF','#785EF0',
-                  '#DC267F','#FE6100','#3D1EB2','#894D80','#16AA02','#B5592B','#A3C1ED']
+        y_min = 0
+        y_max = 115
 
-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]])
+        z_min =0
+        z_max = 10000
 
+        names = True
 
-from matplotlib.pyplot import text
-import inflect
-from scipy.stats import percentileofscore
-p = inflect.engine()
+        ts=[]
+        print(len(data_df))
+        if names:
+            for i in range(len(data_df)):
+                if (data_df[x_stat].values[i] < x_min  or data_df[x_stat].values[i] > x_max ) \
+                and (data_df[y_stat].values[i] < y_min  or data_df[y_stat].values[i] > y_max):
+                    
+                #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[x_stat][i])+0.025/batter_dict_stat[x_stat]['percent_adjust'], data_df[y_stat][i]+0.01/batter_dict_stat[x_stat]['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[x_stat][i]-len(data_df.batter[i])*0.00025, data_df[y_stat][i]+0.001),fontsize=8)
+                    ts.append(ax.text(data_df[x_stat][i], data_df[y_stat][i], data_df.batter_name[i],fontsize=8))
 
 
 
+        ax.hlines(xmin=(math.floor((data_df[x_stat].min()*batter_dict_stat[x_stat]['percent_adjust']-0.01)/5))*5/batter_dict_stat[x_stat]['percent_adjust'],
+                    xmax= (math.ceil((data_df[x_stat].max()*batter_dict_stat[x_stat]['percent_adjust']+0.01)/5))*5/batter_dict_stat[x_stat]['percent_adjust'],
+                    y=data_df[y_stat].mean(),color='gray',linewidth=3,linestyle='dotted',alpha=0.4)
 
-def server(input,output,session):
+        print('we made it here')
 
+        ax.vlines(ymin=(math.floor((data_df[y_stat].min()*batter_dict_stat[y_stat]['percent_adjust']-0.01)/5))*5/batter_dict_stat[y_stat]['percent_adjust'],
+                    ymax= (math.ceil((data_df[y_stat].max()*batter_dict_stat[y_stat]['percent_adjust']+0.01)/5))*5/batter_dict_stat[y_stat]['percent_adjust'],
+                    x=data_df[x_stat].mean(),color='gray',linewidth=3,linestyle='dotted',alpha=0.4)
 
-    @output
-    @render.plot(alt="hex_plot")
-    @reactive.event(input.go, ignore_none=False)
-    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()]
+        print(data_df[x_stat].min())
+        print(batter_dict_stat[x_stat]['percent_adjust'])
+        print((math.floor((data_df[x_stat].min()*batter_dict_stat[x_stat]['percent_adjust']-0.01)/5))*5/batter_dict_stat[x_stat]['percent_adjust'])
 
-        # #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"2024 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')
+        ax.set_xlim((math.floor((data_df[x_stat].min()*batter_dict_stat[x_stat]['percent_adjust'])/5))*5/batter_dict_stat[x_stat]['percent_adjust'],
+                    (math.ceil((data_df[x_stat].max()*batter_dict_stat[x_stat]['percent_adjust'])/5))*5/batter_dict_stat[x_stat]['percent_adjust'])
 
-        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.set_ylim((math.floor((data_df[y_stat].min()*batter_dict_stat[y_stat]['percent_adjust'])/5))*5/batter_dict_stat[y_stat]['percent_adjust'],
+                    (math.ceil((data_df[y_stat].max()*batter_dict_stat[y_stat]['percent_adjust'])/5))*5/batter_dict_stat[y_stat]['percent_adjust'])
 
-        #ax.text(f"Vertical Spray Angle (°)")
 
 
-    @output
-    @render.plot(alt="roll_plot")
-    @reactive.event(input.go, ignore_none=False)
-    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)
+        #title_level = str([x .strip("\'")for x in level_id]).strip('[').strip(']').replace("'",'')
+        title_level = level_id
+        if title_level == 'AAA, AA, A+, A':
+            title_level='MiLB'
+        # #title_level = level_id[0]
+        # if input.n_age() >= 50:
+        #     title_spot = f'{title_level} Batter {batter_dict_stat[y_stat]["title"]} vs {batter_dict_stat[x_stat]["title"]} (min. {n_input} PA)'
+
+        else:
+            title_spot = f'{title_level} Batter - {season} - {batter_dict_stat[y_stat]["title"]} vs {batter_dict_stat[x_stat]["title"]} (min. {n_input} PA)'
+
+        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[x_stat]['x_axis'], fontsize=16,fontname='Century Gothic')
+        ax.set_ylabel(batter_dict_stat[y_stat]['x_axis'], fontsize=16,fontname='Century Gothic')
 
-        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, :])
+        # if input.group_level():
+        #     ax.get_legend().remove()
 
-        axheader.axis('off')
-        ax10.axis('off')
-        ax12.axis('off')
-        axfooter1.axis('off')
+        # if not input.group_level():
+        #     if len(level_id) > 1:
+        #         h,l = scatter.get_legend_handles_labels()
+        #         l[-(len(level_id)+1)] = 'Level'
+        #         ax.legend(h[-(len(level_id)+1):],l[-(len(level_id)+1):], borderaxespad=0.1,loc=0)
 
+        #     else:
+        #         ax.get_legend().remove()
 
-        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)
+        #plt.show(g)
+        # ax.figure.colorbar(sm, 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)')
+        cbar  = ax.figure.colorbar(sm, ax=ax,format=decimal_format_assign(x=batter_dict_stat[z_stat]),orientation='vertical',aspect=30)
+        cbar.set_label(batter_dict_stat[z_stat]['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)
 
-        # ax.hlines(y=df_model_2023.y_pred_no_swing.std()*100,xmin=win,xmax=len(df_will))
+        if batter_dict_stat[x_stat]['flip_p']:
+            fig.axes[0].invert_xaxis()
 
-        # 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])
+        if batter_dict_stat[y_stat]['flip_p']:
+            fig.axes[0].invert_yaxis()
 
 
-        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.xaxis.set_major_formatter(mtick.PercentFormatter(1,decimals=0))
+        # ax.yaxis.set_major_formatter(mtick.PercentFormatter(1))
 
-        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)
+        print('we made it here6')
 
-        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)
+        ax.xaxis.set_major_formatter(decimal_format_assign(x=batter_dict_stat[x_stat]))
+        ax.yaxis.set_major_formatter(decimal_format_assign(x=batter_dict_stat[y_stat]))
 
-        # # 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,))
+        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)
 
-        ax.set_yticks([0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1])
+        print(ts)
+        if len(ts) > 0:
+                adjust_text(ts,
+                            arrowprops=dict(arrowstyle="-", color=colour_palette[4], lw=1),ax=ax)
 
-        ax.set_xlabel('Balls In Play')
-        ax.set_ylabel('Expected Total Bases per Ball In Play (xSLGCON)')
+        #ax.legend(fontsize='16')
+        ax.get_legend().remove()
 
-        from matplotlib.ticker import FormatStrFormatter
+        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()
 
-        ax.yaxis.set_major_formatter(FormatStrFormatter('%.3f'))
+import shinyswatch
+
+
+# app_ui = ui.page_fluid(ui.output_plot("plot",height = "1000px",width="1000px"))
+
+# app = App(ui.page_fluid(ui.output_plot("plot",height = "1000px",width="1000px")),server)
+# app = App(app_ui, server)
 
-        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)
 
 app = App(ui.page_fluid(
 #    ui.tags.base(href=base_url),
@@ -507,99 +363,37 @@ app = App(ui.page_fluid(
     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.markdown("""<a href='https://www.patreon.com/tj_stats'>Support me on Patreon for Access to 2024 Apps</a><sup>1</sup>"""), 
         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.input_action_button("go", "Generate",class_="btn-primary")),
-
-   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)
+
+      ui.panel_sidebar(
+        #ui.output_ui('test','Select Player'),
+        # #ui.input_select("id", "Select Pitcher",batter_dict,selected=675911,width=1,size=1,selectize=True),
+        # #ui.input_select("level_id", "Select Level",level_dict,width=1,size=1),
+        # #ui.input_select("stat_id", "Select Stat",plot_dict_small,width=1,size=1),
+        # ui.input_numeric("n", "Rolling Window Size", value=50),
+        # ui.input_action_button("go", "Generate",class_="btn-primary"),
+        # ui.output_table("result")
+      ),
+
+      ui.panel_main(
+             ui.navset_tab(
+            # ui.nav("Raw Data",
+            #     ui.output_data_frame("raw_table")),                
+            # ui.nav("Season Summary",
+            #        ui.output_plot('plot',
+            #                       width='2000px',
+            #                       height='2000px')),
+            ui.nav("MLB",
+                ui.output_plot("plot",height = "1000px",width="1000px"))
+            # ui.nav("AAA",
+            #     ui.output_plot("plot_aaa",height = "1000px",width="1000px")),
+            # ui.nav("AA",
+            #     ui.output_plot("plot_aa",height = "1000px",width="1000px")) ,              
+            # ui.nav("A+",
+            #     ui.output_plot("plot_ha",height = "1000px",width="1000px")),
+            # ui.nav("A",
+            #     ui.output_plot("plot_a",height = "1000px",width="1000px"))
+
+                ,id="my_tabs")))))),server)