Upload 2 files

app.py

@@ -1,736 +1,544 @@
-from shiny import App, Inputs, Outputs, Session, reactive, render, req, ui
-import datasets
-from datasets import load_dataset
+from shiny import ui, render, App
+import matplotlib.image as mpimg
 import pandas as pd
+import pygsheets
+import pytz
+from datetime import datetime
 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'),
+print('Starting')
+df_2024 = pd.read_csv('2024_spring_data.csv',index_col=[0])
+print('Starting')
+spring_teams = df_2024.groupby(['pitcher_id']).tail(1)[['pitcher_id','pitcher_team']].set_index(['pitcher_id'])['pitcher_team'].to_dict()
+
+
+df_2024['vy_f'] = -(df_2024['vy0']**2 - (2 * df_2024['ay'] * (df_2024['y0'] - 17/12)))**0.5
+df_2024['t'] = (df_2024['vy_f'] - df_2024['vy0']) / df_2024['ay']
+df_2024['vz_f'] = (df_2024['vz0']) + (df_2024['az'] * df_2024['t'])
+df_2024['vaa'] = -np.arctan(df_2024['vz_f'] / df_2024['vy_f']) * (180 / np.pi)
+
+#df_2024['vy_f'] = -(df_2024['vy0']**2 - (2 * df_2024['ay'] * (df_2024['y0'] - 17/12)))**0.5
+#df_2024['t'] = (df_2024['vy_f'] - df_2024['vy0']) / df_2024['ay']
+df_2024['vx_f'] = (df_2024['vx0']) + (df_2024['ax'] * df_2024['t'])
+df_2024['haa'] = -np.arctan(df_2024['vx_f'] / df_2024['vy_f']) * (180 / np.pi)
+grouped_ivb_2023 = pd.read_csv('2023_pitch_group_data.csv',index_col=[0,3])
+
+model = joblib.load('tjstuff_model_20240123.joblib')
+
+
+def percentile(n):
+    def percentile_(x):
+        return x.quantile(n)
+    percentile_.__name__ = 'percentile_{:02.0f}'.format(n*100)
+    return percentile_
+
+def df_clean(df):
+    df_copy = df.copy()
+    df_copy.loc[df_copy['pitcher_hand'] == 'L','hb'] *= -1
+    df_copy.loc[df_copy['pitcher_hand'] == 'L','x0'] *= -1
+    df_copy.loc[df_copy['pitcher_hand'] == 'L','spin_direction'] = 360 - df_copy.loc[df_copy['pitcher_hand'] == 'L','spin_direction']
+
+    df_copy['pitch_l'] = [1 if x == 'L' else 0 for x in df_copy['pitcher_hand']]
+    df_copy['bat_l'] = [1 if x == 'L' else 0 for x in df_copy['batter_hand']]
+    df_copy = df_copy[~df_copy.pitch_type.isin(["EP", "PO", "KN", "FO", "CS", "SC", "FA"])].reset_index(drop=True)
+    df_copy['pitch_type'] = df_copy['pitch_type'].replace({'FT':'SI','KC':'CU','ST':'SL','SV':'SL'})
+
+    # df_copy['des_new'] = df_copy['play_description'].map(des_dict)
+    # df_copy['ev_new'] = df_copy.loc[df_copy['des_new'] == 'hit_into_play','event_type'].map(ev_dict)
+    # df_copy.loc[df_copy['des_new']=='hit_into_play','des_new'] = df_copy.loc[df_copy['des_new']=='hit_into_play','ev_new']
+    # df_copy = df_copy.dropna(subset=['des_new'])
+    # des_values = df_copy.groupby(['des_new'])['delta_run_exp'].mean()
+    # df_copy = df_copy.merge(des_values,left_on='des_new',right_on='des_new',suffixes=['','_mean'])
+
+    df_copy_fb_sum = df_copy[df_copy.pitch_type.isin(["FF", "FC", "SI"])].groupby(['pitcher_id']).agg(
+        fb_velo = ('start_speed','mean'),
+        fb_max_ivb  = ('ivb',percentile(0.9)),
+        fb_max_x  = ('hb',percentile(0.9)),
+        fb_min_x  = ('hb',percentile(0.1)),
+        fb_max_velo  = ('start_speed',percentile(0.9)),
+        fb_axis  = ('spin_direction','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')
-    )
+    df_copy = df_copy.merge(df_copy_fb_sum,left_on='pitcher_id',right_index=True,how='left')
 
-# 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)))
+    df_copy['fb_velo_diff'] = df_copy['start_speed']- df_copy['fb_velo']
+    df_copy['fb_max_ivb_diff'] = df_copy['ivb']- df_copy['fb_max_ivb']
+    df_copy['fb_max_hb_diff'] = df_copy['hb']- df_copy['fb_max_x']
+    df_copy['fb_min_hb_diff'] = df_copy['hb']- df_copy['fb_min_x']
+    df_copy['fb_max_velo_diff'] = df_copy['start_speed']- df_copy['fb_max_velo']
+    df_copy['fb_axis_diff'] = df_copy['spin_direction']- df_copy['fb_axis']
 
-## 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')
-    )
+    # df_copy.loc[df_copy.pitch_type.isin(["FF", "FC", "SI"]),'fb_velo_diff'] = 0
+    # df_copy.loc[df_copy.pitch_type.isin(["FF", "FC", "SI"]),'fb_max_ivb_diff'] = 0
+    # df_copy.loc[df_copy.pitch_type.isin(["FF", "FC", "SI"]),'fb_max_hb_diff'] = 0
+    # df_copy.loc[df_copy.pitch_type.isin(["FF", "FC", "SI"]),'fb_min_hb_diff'] = 0
+    # df_copy.loc[df_copy.pitch_type.isin(["FF", "FC", "SI"]),'fb_max_velo_diff'] = 0
+    # df_copy.loc[df_copy.pitch_type.isin(["FF", "FC", "SI"]),'fb_axis_diff'] = 0
 
-# 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
+    df_copy['max_speed'] = df_copy.groupby(['pitcher_id'])['start_speed'].transform('max')
+    df_copy['max_speed_diff'] = df_copy['start_speed'] - df_copy['max_speed']
 
-# 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_copy['max_ivb'] = df_copy.groupby(['pitcher_id'])['ivb'].transform('max')
+    df_copy['max_ivb_diff'] = df_copy['ivb'] - df_copy['max_ivb']
 
-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_copy['vy_f'] = -(df_copy['vy0']**2 - (2 * df_copy['ay'] * (df_copy['y0'] - 17/12)))**0.5
+    df_copy['t'] = (df_copy['vy_f'] - df_copy['vy0']) / df_copy['ay']
+    df_copy['vz_f'] = (df_copy['vz0']) + (df_copy['az'] * df_copy['t'])
+    df_copy['vaa'] = -np.arctan(df_copy['vz_f'] / df_copy['vy_f']) * (180 / np.pi)
 
-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_copy['vy_f'] = -(df_copy['vy0']**2 - (2 * df_copy['ay'] * (df_copy['y0'] - 17/12)))**0.5
+    #df_copy['t'] = (df_copy['vy_f'] - df_copy['vy0']) / df_copy['ay']
+    df_copy['vx_f'] = (df_copy['vx0']) + (df_copy['ax'] * df_copy['t'])
+    df_copy['haa'] = -np.arctan(df_copy['vx_f'] / df_copy['vy_f']) * (180 / np.pi)
 
-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
+    # df_copy['x_diff'] = df_copy['x0'] - df_copy['px']
+    # df_copy['z_diff'] = df_copy['z0'] - df_copy['pz']
 
-colour_palette = ['#FFB000','#648FFF','#785EF0',
-                  '#DC267F','#FE6100','#3D1EB2','#894D80','#16AA02','#B5592B','#A3C1ED']
+    # df_copy['vaa'] = np.arctan(df_copy['z_diff'] / df_copy['release_pos_y']) * 360 / np.pi
+    # df_copy['haa'] = np.arctan(-df_copy['x_diff'] / df_copy['release_pos_y']) * 360 / np.pi
 
-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]])
+    df_copy = df_copy.dropna(subset=['pitch_type']).fillna(0)
+    return df_copy
 
 
-from matplotlib.pyplot import text
-import inflect
-from scipy.stats import percentileofscore
-p = inflect.engine()
+app_ui = ui.page_fluid(
+    ui.layout_sidebar(
+ 
+        ui.panel_sidebar(
+                ui.input_date_range("date_range_id", "Date range input",start = df_2024.game_date.min(),
+                                     end = df_2024.game_date.max(),width=2,min=df_2024.game_date.min(),
+                                       max=df_2024.game_date.max()),width=2),
+        ui.panel_main(     
+            ui.navset_tab(
+            # ui.nav("Raw Data",
+            #     ui.output_data_frame("raw_table")),                
+            ui.nav("Pitch Data",
+                ui.output_data_frame("table")),
+            ui.nav("Pitch Data (Daily)",
+                ui.output_data_frame("table_daily")),          
+            ui.nav("2023 vs Spring",
+                ui.output_data_frame("table_2023")),          
+            ui.nav("2023 vs Spring Difference",
+                ui.output_data_frame("table_difference")),     
+            # ui.nav("New Pitches",
+            #     ui.output_data_frame("table_new")),     
+            ui.nav("tjStuff+",
+                ui.output_data_frame("table_stuff")),     
+            ui.nav("tjStuff+ (Daily)",
+                ui.output_data_frame("table_stuff_day")),     
+
+                ))))
+
+
+from urllib.request import Request, urlopen
+from shiny import App, reactive, ui
+from shiny.ui import h2, tags
+# importing OpenCV(cv2) module
+
+
+
+
+#print(app_ui)
+def server(input, output, session):
+
+    # @output
+    # @render.data_frame
+    # def raw_table():
+
+    #     return render.DataGrid(
+    #         df_2024,
+    #         width='fit-content',
+    #         height=750,
+    #         filters=True,
+    #     )        
 
+    @output
+    @render.data_frame
+    def table():
 
+        grouped_ivb = df_2024[(pd.to_datetime(df_2024['game_date']).dt.date>=input.date_range_id()[0])&
+                              (pd.to_datetime(df_2024['game_date']).dt.date<=input.date_range_id()[1])].groupby(['pitcher_id','pitcher_name','pitcher_team','pitcher_hand','pitch_type']).agg(
+        pitches = ('start_speed','count'),
+        
+        start_speed = ('start_speed','mean'),
+        ivb = ('ivb','mean'),
+        hb = ('hb','mean'),
+        spin_rate = ('spin_rate','mean'),
+        vaa = ('vaa','mean'),
+        haa = ('haa','mean'),
+        horizontal_release = ('x0','mean'),
+        vertical_release = ('z0','mean'),
+        extension = ('extension','mean')).round(1).reset_index()
+        #grouped_ivb = grouped_ivb.set_index(['pitcher_id']).reset_index()
+        # return     grouped_ivb    
+        return render.DataGrid(
+            grouped_ivb,
+            width='fit-content',
+            height=750,
+            filters=True,
+        )        
 
+    @output
+    @render.data_frame
+    def table_daily():
 
-def server(input,output,session):
+        grouped_ivb = df_2024[(pd.to_datetime(df_2024['game_date']).dt.date>=input.date_range_id()[0])&
+                              (pd.to_datetime(df_2024['game_date']).dt.date<=input.date_range_id()[1])].groupby(['pitcher_id','pitcher_name','pitcher_team','pitcher_hand','pitch_type','game_date']).agg(
+        pitches = ('start_speed','count'),
+        
+        start_speed = ('start_speed','mean'),
+        ivb = ('ivb','mean'),
+        hb = ('hb','mean'),
+        spin_rate = ('spin_rate','mean'),
+        vaa = ('vaa','mean'),
+        haa = ('haa','mean'),
+        horizontal_release = ('x0','mean'),
+        vertical_release = ('z0','mean'),
+        extension = ('extension','mean')).round(1).reset_index()
+        #grouped_ivb = grouped_ivb.set_index(['pitcher_id']).reset_index()
+        # return     grouped_ivb    
+        return render.DataGrid(
+            grouped_ivb,
+            width='fit-content',
+            height=750,
+            filters=True,
+        )             
+        
+        #return grouped_ivb
 
     @output
-    @render.plot(alt="hex_plot")
-    @reactive.event(input.go, ignore_none=False)
-    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)
+    @render.data_frame
+    def table_2023():
+        grouped_ivb = df_2024[(pd.to_datetime(df_2024['game_date']).dt.date>=input.date_range_id()[0])&
+                              (pd.to_datetime(df_2024['game_date']).dt.date<=input.date_range_id()[1])].groupby(['pitcher_id','pitcher_name','pitcher_hand','pitch_type']).agg(
+            pitches = ('start_speed','count'),
+            
+            start_speed = ('start_speed','mean'),
+            ivb = ('ivb','mean'),
+            hb = ('hb','mean'),
+            spin_rate = ('spin_rate','mean'),
+            vaa = ('vaa','mean'),
+            haa = ('haa','mean'),
+            horizontal_release = ('x0','mean'),
+            vertical_release = ('z0','mean'),
+            extension = ('extension','mean')).round(1).reset_index()
+        grouped_ivb = grouped_ivb.set_index(['pitcher_id','pitch_type'])
 
+        
+
+        #####
+        ivb_merged = grouped_ivb_2023.merge(right=grouped_ivb,
+                            left_index=True,
+                            right_index=True,
+                            how='right',suffixes=['_2023','_spring']).reset_index()
+
+        ivb_merged['pitcher_name'] = ivb_merged['pitcher_name_spring']
+        ivb_merged['pitcher_hand'] = ivb_merged['pitcher_hand_spring']
+        #ivb_merged['pitch_type'] = ivb_merged['pitch_type_spring']
+
+
+        # ivb_merged = ivb_merged[['pitcher_id', 'pitcher_name', 'pitcher_hand', 'pitch_type',
+        #      'pitches_spring', 'start_speed_spring', 'ivb_spring',
+        #        'hb_spring', 'spin_rate_spring', 'horizontal_release_spring',
+        #        'vertical_release_spring', 'extension_spring']]
+        ivb_merged['pitcher_team'] = ivb_merged['pitcher_id'].map(spring_teams)
+        ivb_merged = ivb_merged.set_index(['pitcher_id', 'pitcher_name','pitcher_team', 'pitcher_hand', 'pitch_type',])
+
+        return render.DataGrid(
+            ivb_merged[['pitches_2023','start_speed_2023', 'ivb_2023', 'hb_2023',
+       'spin_rate_2023', 'vaa_2023','haa_2023', 'horizontal_release_2023', 'vertical_release_2023',
+       'extension_2023','pitches_spring','start_speed_spring', 'ivb_spring', 'hb_spring',
+       'spin_rate_spring','vaa_spring','haa_spring', 'horizontal_release_spring', 'vertical_release_spring',
+       'extension_spring',]].reset_index(),
+            width='fit-content',
+            height=750,
+            filters=True,
+        )             
+               
     @output
-    @render.plot(alt="hex_plot")
-    @reactive.event(input.go, ignore_none=False)
-    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
+    @render.data_frame
+    def table_difference():
+        grouped_ivb = df_2024[(pd.to_datetime(df_2024['game_date']).dt.date>=input.date_range_id()[0])&
+                              (pd.to_datetime(df_2024['game_date']).dt.date<=input.date_range_id()[1])].groupby(['pitcher_id','pitcher_name','pitcher_hand','pitch_type']).agg(
+            pitches = ('start_speed','count'),
+            
+            start_speed = ('start_speed','mean'),
+            ivb = ('ivb','mean'),
+            hb = ('hb','mean'),
+            spin_rate = ('spin_rate','mean'),
+            vaa = ('vaa','mean'),
+            haa = ('haa','mean'),
+            horizontal_release = ('x0','mean'),
+            vertical_release = ('z0','mean'),
+            extension = ('extension','mean')).round(1).reset_index()
+        grouped_ivb = grouped_ivb.set_index(['pitcher_id','pitch_type'])
+
         
-        player_select = int(input.batter_id())
-        player_select_full = batter_dict[player_select]
 
+        #####
+        ivb_merged = grouped_ivb_2023.merge(right=grouped_ivb,
+                            left_index=True,
+                            right_index=True,
+                            how='right',suffixes=['_2023','_spring']).reset_index()
+
+        ivb_merged['pitcher_name'] = ivb_merged['pitcher_name_spring']
+        ivb_merged['pitcher_hand'] = ivb_merged['pitcher_hand_spring']
+        #ivb_merged['pitch_type'] = ivb_merged['pitch_type_spring']
+
+
+        # ivb_merged = ivb_merged[['pitcher_id', 'pitcher_name', 'pitcher_hand', 'pitch_type',
+        #      'pitches_spring', 'start_speed_spring', 'ivb_spring',
+        #        'hb_spring', 'spin_rate_spring', 'horizontal_release_spring',
+        #        'vertical_release_spring', 'extension_spring']]
+        ivb_merged['pitcher_team'] = ivb_merged['pitcher_id'].map(spring_teams)
+        ivb_merged = ivb_merged.set_index(['pitcher_id', 'pitcher_name','pitcher_team', 'pitcher_hand', 'pitch_type',])
+
+        ivb_merged[['start_speed_difference', 'ivb_difference', 'hb_difference','spin_rate_difference','vaa_difference','haa_difference',
+                'horizontal_release_difference', 'vertical_release_difference',
+            'extension_difference']] = ivb_merged[['start_speed_spring', 'ivb_spring', 'hb_spring',
+            'spin_rate_spring', 'vaa_spring','haa_spring','horizontal_release_spring', 'vertical_release_spring',
+            'extension_spring']].values - ivb_merged[['start_speed_2023', 'ivb_2023', 'hb_2023',
+            'spin_rate_2023', 'vaa_2023','haa_2023','horizontal_release_2023', 'vertical_release_2023',
+            'extension_2023']].values
+
+
+        return render.DataGrid(
+            ivb_merged[['start_speed_difference', 'ivb_difference', 'hb_difference',
+       'spin_rate_difference', 
+       'vaa_difference','haa_difference','horizontal_release_difference', 'vertical_release_difference',
+       'extension_difference']].reset_index(),
+            width='fit-content',
+            height=750,
+            filters=True,
+        )                  
+
+    # @output
+    # @render.data_frame
+    # def table_new():
+    #     grouped_ivb = df_2024.groupby(['pitcher_id','pitcher_name','pitcher_hand','pitch_type']).agg(
+    #         pitches = ('start_speed','count'),
+            
+    #         start_speed = ('start_speed','mean'),
+    #         ivb = ('ivb','mean'),
+    #         hb = ('hb','mean'),
+    #         spin_rate = ('spin_rate','mean'),
+    #         vaa = ('vaa','mean'),
+    #         haa = ('haa','mean'),
+    #         horizontal_release = ('x0','mean'),
+    #         vertical_release = ('z0','mean'),
+    #         extension = ('extension','mean')).round(1).reset_index()
+    #     grouped_ivb = grouped_ivb.set_index(['pitcher_id','pitch_type'])
+
+    #     grouped_ivb_2023 = pd.read_csv('2023_pitch_group_data.csv',index_col=[0,3])
+
+    #     #####
+    #     ivb_merged = grouped_ivb_2023.merge(right=grouped_ivb,
+    #                         left_index=True,
+    #                         right_index=True,
+    #                         how='right',suffixes=['_2023','_spring']).reset_index()
+
+    #     ivb_merged['pitcher_name'] = ivb_merged['pitcher_name_spring']
+    #     ivb_merged['pitcher_hand'] = ivb_merged['pitcher_hand_spring']
+    #     #ivb_merged['pitch_type'] = ivb_merged['pitch_type_spring']
+
+
+    #     # ivb_merged = ivb_merged[['pitcher_id', 'pitcher_name', 'pitcher_hand', 'pitch_type',
+    #     #      'pitches_spring', 'start_speed_spring', 'ivb_spring',
+    #     #        'hb_spring', 'spin_rate_spring', 'horizontal_release_spring',
+    #     #        'vertical_release_spring', 'extension_spring']]
+    #     ivb_merged['pitcher_team'] = ivb_merged['pitcher_id'].map(spring_teams)
+    #     ivb_merged = ivb_merged.set_index(['pitcher_id', 'pitcher_name','pitcher_team', 'pitcher_hand', 'pitch_type',])
+
+
+
+
+
+
+    #     ivb_merged[['start_speed_difference', 'ivb_difference', 'hb_difference','spin_rate_difference','vaa_difference','haa_difference',
+    #             'horizontal_release_difference', 'vertical_release_difference',
+    #         'extension_difference']] = ivb_merged[['start_speed_spring', 'ivb_spring', 'hb_spring',
+    #         'spin_rate_spring', 'vaa_spring','haa_spring','horizontal_release_spring', 'vertical_release_spring',
+    #         'extension_spring']].values - ivb_merged[['start_speed_2023', 'ivb_2023', 'hb_2023',
+    #         'spin_rate_2023', 'vaa_2023','haa_2023','horizontal_release_2023', 'vertical_release_2023',
+    #         'extension_2023']].values
+    #     ivb_merged_new = ivb_merged.reset_index()
+
+    #     ivb_merged_new = ivb_merged_new[
+    #         pd.isnull(ivb_merged_new['pitches_2023']) & 
+    #         pd.notnull(ivb_merged_new['pitches_spring']) &
+    #         ivb_merged_new['pitcher_id'].isin(ivb_merged_new[pd.notnull(ivb_merged_new['pitches_2023'])]['pitcher_id'])
+    #     ][
+
+    #         ['pitcher_id', 'pitcher_name', 'pitcher_hand', 'pitch_type',
+    #         'pitches_spring', 'start_speed_spring', 'ivb_spring',
+    #         'hb_spring', 'spin_rate_spring', 'vaa_spring','haa_spring', 'horizontal_release_spring',
+    #         'vertical_release_spring', 'extension_spring']
+    #     ]#.reset_index()
+
+    #     # ivb_merged_new = ivb_merged.copy().reset_index()
+    #     ivb_merged_new['pitcher_team'] = ivb_merged_new['pitcher_id'].map(spring_teams)
+    #     ivb_merged_new = ivb_merged_new.set_index(['pitcher_id', 'pitcher_name','pitcher_team', 'pitcher_hand', 'pitch_type',])
+    #     #ivb_merged_new.to_clipboard(header=False)
+    #     df_2024_date_min = df_2024.groupby(['pitcher_id','pitcher_name','pitcher_hand','pitch_type','game_date'])[['game_date']].min()
+    #     ivb_merged_new = ivb_merged_new.merge(right=df_2024_date_min,
+    #                                         left_index=True,
+    #                                         right_index=True)
+    #     ivb_merged_new = ivb_merged_new.drop(columns=['game_date'])
+
+    #     return render.DataGrid(
+    #         ivb_merged_new.reset_index(),
+    #         width='fit-content',
+    #         height=750,
+    #         filters=True,
+    #     )                  
 
-        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()
+    @output
+    @render.data_frame
+    def table_stuff():
+   
 
-        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)
+        df_2024_update = df_clean(df_2024[(pd.to_datetime(df_2024['game_date']).dt.date>=input.date_range_id()[0])&
+                              (pd.to_datetime(df_2024['game_date']).dt.date<=input.date_range_id()[1])])
 
-        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])
+        features = ['start_speed','spin_rate','extension','ivb','hb','x0','z0','fb_max_velo_diff','fb_max_ivb_diff','fb_max_hb_diff']
 
-        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, :])
+        targets = ['delta_run_exp_mean']
 
-        axheader.axis('off')
-        ax10.axis('off')
-        ax12.axis('off')
-        axfooter1.axis('off')
 
+        from scipy import stats
+        df_2024_update['y_pred'] = model.predict(df_2024_update[features])
 
-        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)')
+        y_pred_mean = -0.0023964706
+        y_pred_std =0.0057581966
+        # y_pred_mean = -0.0136602735
+        # y_pred_std = 0.006434487
 
-        # ax.hlines(y=df_model_2023.y_pred.std()*100,xmin=win,xmax=len(df_will))
+        ## tjStuff+
+        df_2024_stuff = df_2024_update.groupby(['pitcher_id','pitcher_name','pitcher_team']).agg(
+            pitches = ('y_pred','count'),
+            run_exp = ('y_pred','mean'),)
+        # run_exp_loc = ('y_pred_loc','mean'))
 
-        # 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])
+        df_2024_stuff['run_exp_mean'] = y_pred_mean
+        df_2024_stuff['run_exp_std'] = y_pred_std
 
+        df_2024_stuff_50 = df_2024_stuff[df_2024_stuff.pitches >= 1]
 
-        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')
+        df_2024_stuff_50['tj_stuff_plus'] = 100 + 10*((-df_2024_stuff_50.run_exp + df_2024_stuff_50.run_exp_mean) / df_2024_stuff_50.run_exp_std)
 
-        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]
+        df_2024_stuff_pitch = df_2024_update.groupby(['pitcher_id','pitcher_name','pitcher_team','pitch_type']).agg(
+            pitches = ('y_pred','count'),
+            run_exp = ('y_pred','mean'),)
+        # run_exp_loc = ('y_pred_loc','mean'))
 
+        df_2024_stuff_pitch['run_exp_mean'] = y_pred_mean
+        df_2024_stuff_pitch['run_exp_std'] = y_pred_std
 
+        df_2024_stuff_pitch_50 = df_2024_stuff_pitch[df_2024_stuff_pitch.pitches >= 1]
 
-        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)
+        df_2024_stuff_pitch_50['tj_stuff_plus'] = 100 + 10*((-df_2024_stuff_pitch_50.run_exp + df_2024_stuff_pitch_50.run_exp_mean) / df_2024_stuff_pitch_50.run_exp_std)
 
-        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)
+        df_2024_stuff_pitch_50_pivot = df_2024_stuff_pitch_50.reset_index().pivot(index=['pitcher_id','pitcher_name','pitcher_team'],
+                                    columns=['pitch_type'],
+                                    values=['tj_stuff_plus'])
 
-        # # 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')
+        df_2024_stuff_pitch_50_pivot['all'] = df_2024_stuff_pitch_50_pivot.index.map(df_2024_stuff_50['tj_stuff_plus'].to_dict())
+        ## Difference
+        print('Sheet6')
+        df_2024_stuff_pitch_50_pivot = df_2024_stuff_pitch_50_pivot.sort_index(level=[1])        
+        df_2024_stuff_pitch_50_pivot.columns = df_2024_stuff_pitch_50_pivot.columns.droplevel()
+        column_list = list(df_2024_stuff_pitch_50_pivot.columns[:-1])
+        column_list.append('All')
+        df_2024_stuff_pitch_50_pivot.columns = column_list
+        df_2024_stuff_pitch_50_pivot = df_2024_stuff_pitch_50_pivot.applymap(lambda x: int(x) if not pd.isna(x) else x)
+        df_2024_stuff_pitch_50_pivot = df_2024_stuff_pitch_50_pivot.reset_index()
 
-        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)')
+        return render.DataGrid(
+            df_2024_stuff_pitch_50_pivot,
+            width='fit-content',
+            height=750,
+            filters=True)          
+    
+    @output
+    @render.data_frame
+    def table_stuff_day():
 
-        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])
+        df_2024_update = df_clean(df_2024[(pd.to_datetime(df_2024['game_date']).dt.date>=input.date_range_id()[0])&
+                              (pd.to_datetime(df_2024['game_date']).dt.date<=input.date_range_id()[1])])
+        print('made it here')
 
-    @output
-    @render.plot(alt="hex_plot")
-    @reactive.event(input.go, ignore_none=False)
-    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]
+        features = ['start_speed','spin_rate','extension','ivb','hb','x0','z0','fb_max_velo_diff','fb_max_ivb_diff','fb_max_hb_diff']
 
+        targets = ['delta_run_exp_mean']
 
-        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])
+        from scipy import stats
+        df_2024_update['y_pred'] = model.predict(df_2024_update[features])
 
-        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')
+        y_pred_mean = -0.0023964706
+        y_pred_std =0.0057581966
+        # y_pred_mean = -0.0136602735
+        # y_pred_std = 0.006434487
 
+        ## tjStuff+
+        df_2024_stuff_daily = df_2024_update.groupby(['pitcher_id','pitcher_name','pitcher_team','game_date']).agg(
+            pitches = ('y_pred','count'),
+            run_exp = ('y_pred','mean'),)
+        # run_exp_loc = ('y_pred_loc','mean'))
 
-        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)
+        df_2024_stuff_daily['run_exp_mean'] = y_pred_mean
+        df_2024_stuff_daily['run_exp_std'] = y_pred_std
 
-        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)')
+        df_2024_stuff_daily_50 = df_2024_stuff_daily[df_2024_stuff_daily.pitches >= 1]
 
-        # ax.hlines(y=df_model_2023.y_pred_no_swing.std()*100,xmin=win,xmax=len(df_will))
+        df_2024_stuff_daily_50['tj_stuff_plus'] = 100 + 10*((-df_2024_stuff_daily_50.run_exp + df_2024_stuff_daily_50.run_exp_mean) / df_2024_stuff_daily_50.run_exp_std)
 
-        # 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])
 
+        df_2024_stuff_daily_pitch = df_2024_update.groupby(['pitcher_id','pitcher_name','pitcher_team','pitch_type','game_date']).agg(
+            pitches = ('y_pred','count'),
+            run_exp = ('y_pred','mean'),)
+        # run_exp_loc = ('y_pred_loc','mean'))
 
-        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')
+        df_2024_stuff_daily_pitch['run_exp_mean'] = y_pred_mean
+        df_2024_stuff_daily_pitch['run_exp_std'] = y_pred_std
 
-        ax.legend()
+        df_2024_stuff_daily_pitch_50 = df_2024_stuff_daily_pitch[df_2024_stuff_daily_pitch.pitches >= 1]
 
-        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]
+        df_2024_stuff_daily_pitch_50['tj_stuff_plus'] = 100 + 10*((-df_2024_stuff_daily_pitch_50.run_exp + df_2024_stuff_daily_pitch_50.run_exp_mean) / df_2024_stuff_daily_pitch_50.run_exp_std)
+        df_2024_stuff_daily_pitch_50 = df_2024_stuff_daily_pitch_50.reset_index()
+        df_2024_stuff_daily_pitch_50_pivot = df_2024_stuff_daily_pitch_50.pivot(index=['pitcher_id','pitcher_name','pitcher_team','game_date'],
+                                    columns=['pitch_type'],
+                                    values=['tj_stuff_plus'])
+        print('made it here')
+        df_2024_stuff_daily_pitch_50_pivot['all'] = df_2024_stuff_daily_pitch_50_pivot.index.map(df_2024_stuff_daily_50['tj_stuff_plus'].to_dict())
+        df_2024_stuff_daily_pitch_50_pivot = df_2024_stuff_daily_pitch_50_pivot.sort_index(level=[1,3])   
+        print(df_2024_stuff_daily_pitch_50_pivot)
 
+        df_2024_stuff_daily_pitch_50_pivot.columns = df_2024_stuff_daily_pitch_50_pivot.columns.droplevel()
+        column_list = list(df_2024_stuff_daily_pitch_50_pivot.columns[:-1])
+        column_list.append('All')
+        df_2024_stuff_daily_pitch_50_pivot.columns = column_list
+        df_2024_stuff_daily_pitch_50_pivot = df_2024_stuff_daily_pitch_50_pivot.applymap(lambda x: int(x) if not pd.isna(x) else x)
+        df_2024_stuff_daily_pitch_50_pivot = df_2024_stuff_daily_pitch_50_pivot.reset_index()
 
+        return render.DataGrid(
+            df_2024_stuff_daily_pitch_50_pivot,
+            width='fit-content',
+            height=750,
+            filters=True)          
 
-        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")
-    @reactive.event(input.go, ignore_none=False)
-    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)   
-
-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="home/"
-    #         ),
-    #     ),
-    #     ui.nav_menu(
-    #         "Batter Charts",
-    #         ui.nav_control(
-    #         ui.a(
-    #             "Batting Rolling",
-    #             href="rolling_batter/"
-    #         ),
-    #         ui.a(
-    #             "Spray & Damage",
-    #             href="https://nesticot-tjstats-site-spray.hf.space/"
-    #         ),
-    #         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.a(
-    #             "Statcast Compare",
-    #             href="statcast_compare/"
-    #         )
-    #     ),
-    #     ),
-    #     ui.nav_menu(
-    #         "Pitcher Charts",
-    #         ui.nav_control(
-    #          ui.a(
-    #             "Pitcher Rolling",
-    #             href="rolling_pitcher/"
-    #         ),
-    #          ui.a(
-    #             "Pitcher Summary",
-    #             href="pitching_summary_graphic_new/"
-    #         ),
-    #          ui.a(
-    #             "Pitcher Scatter",
-    #             href="pitcher_scatter/"
-    #         )
-    #     ),
-    #     )),
-    ui.navset_tab(
-        ui.nav_control(
-             ui.a(
-                "Home",
-                href="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_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.input_action_button("go", "Generate",class_="btn-primary"),
-                                 ),
-
-   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)
+app = App(app_ui, server)

tjstuff_model_20240123.joblib

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