Upload 29 files

functions/app.py

@@ -0,0 +1,451 @@
+import polars as pl
+import numpy as np
+import pandas as pd
+import api_scraper
+scrape = api_scraper.MLB_Scrape()
+from functions import df_update
+from functions import pitch_summary_functions
+update = df_update.df_update()
+from stuff_model import feature_engineering as fe
+from stuff_model import stuff_apply
+import requests
+import joblib
+from matplotlib.gridspec import GridSpec
+from shiny import App, reactive, ui, render
+from shiny.ui import h2, tags
+import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec
+import seaborn as sns
+from functions.pitch_summary_functions import *
+from functions.df_update import *
+from shiny import App, reactive, ui, render
+from shiny.ui import h2, tags
+from functions.heat_map_functions import *
+
+colour_palette = ['#FFB000','#648FFF','#785EF0',
+                  '#DC267F','#FE6100','#3D1EB2','#894D80','#16AA02','#B5592B','#A3C1ED']
+
+
+year_list = [2017,2018,2019,2020,2021,2022,2023,2024]
+
+
+
+level_dict =  {'1':'MLB',
+               '11':'AAA',
+               '12':'AA',
+               '13':'A+',
+               '14':'A',
+               '17':'AFL',
+               '22':'College',
+               '21':'Prospects',
+               '51':'International' }
+
+function_dict={
+    'velocity_kdes':'Velocity Distributions',
+    'break_plot':'Pitch Movement',
+    'tj_stuff_roling':'Rolling tjStuff+ by Pitch',
+    'tj_stuff_roling_game':'Rolling tjStuff+ by Game',
+    'location_plot_lhb':'Locations vs LHB',
+    'location_plot_rhb':'Locations vs RHB',
+}
+
+
+split_dict =  {'all':'All',
+               'left':'LHH',
+               'right':'RHH'}
+
+split_dict_hand =  {'all':['L','R'],
+               'left':['L'],
+               'right':['R']}
+
+
+type_dict =  {'R':'Regular Season',
+               'S':'Spring',
+               'P':'Playoffs' }
+
+format_dict = {
+    'pitch_percent': '{:.1%}',
+    'pitches': '{:.0f}',
+    'heart_zone_percent': '{:.1%}',
+    'shadow_zone_percent': '{:.1%}',
+    'chase_zone_percent': '{:.1%}',
+    'waste_zone_percent': '{:.1%}',
+    'csw_percent': '{:.1%}',
+    'whiff_rate': '{:.1%}',
+    'chase_percent': '{:.1%}',
+    'bip': '{:.0f}',
+    'xwoba_percent_contact': '{:.3f}'
+}
+
+format_dict = {
+    'pitch_percent': '{:.1%}',
+    'pitches': '{:.0f}',
+    'heart_zone_percent': '{:.1%}',
+    'shadow_zone_percent': '{:.1%}',
+    'chase_zone_percent': '{:.1%}',
+    'waste_zone_percent': '{:.1%}',
+    'csw_percent': '{:.1%}',
+    'whiff_rate': '{:.1%}',
+    'chase_percent': '{:.1%}',
+    'bip': '{:.0f}',
+    'xwoba_percent_contact': '{:.3f}'
+}
+label_translation_dict = {
+    'pitch_percent': 'Pitch%',
+    'pitches': 'Pitches',
+    'heart_zone_percent': 'Heart%',
+    'shadow_zone_percent': 'Shado%',
+    'chase_zone_percent': 'Chas%',
+    'waste_zone_percent': 'Waste%',
+    'csw_percent': 'CSW%',
+    'whiff_rate': 'Whiff%',
+    'chase_percent': 'O-Swing%',
+    'bip': 'BBE',
+    'xwoba_percent_contact': 'xwOBACON'
+}
+
+
+cmap_sum = matplotlib.colors.LinearSegmentedColormap.from_list("", ['#648FFF','#FFFFFF','#FFB000',])
+cmap_sum2 = matplotlib.colors.LinearSegmentedColormap.from_list("", ['#FFFFFF','#FFB000','#FE6100'])
+
+
+from shiny import App, reactive, ui, render
+from shiny.ui import h2, tags
+
+# Define the UI layout for the app
+app_ui = ui.page_fluid(
+    ui.layout_sidebar(
+        ui.panel_sidebar(
+            # Row for selecting season and level
+            ui.row(
+                ui.column(4, ui.input_select('year_input', 'Select Season', year_list, selected=2024)),
+                ui.column(4, ui.input_select('level_input', 'Select Level', level_dict)),
+                ui.column(4, ui.input_select('type_input', 'Select Type', type_dict,selected='R'))
+            ),
+            # Row for the action button to get player list
+            ui.row(ui.input_action_button("player_button", "Get Player List", class_="btn-primary")),
+            # Row for selecting the player
+            ui.row(ui.column(12, ui.output_ui('player_select_ui', 'Select Player'))),
+            # Row for selecting the date range
+
+            # Rows for selecting plots and split options
+            ui.row(ui.column(12, ui.output_ui('pitch_type_ui', 'Select Pitch Type'))),
+
+            ui.row(ui.column(12, ui.output_ui('date_id', 'Select Date'))),
+
+
+            
+            # Row for the action button to generate plot
+            ui.row(ui.input_action_button("generate_plot", "Generate Plot", class_="btn-primary")),
+        ),
+                
+        ui.panel_main(
+            ui.navset_tab(
+                # Tab for game summary plot
+                ui.nav("Pitching Summary",
+                       ui.output_text("status"),
+                       ui.output_plot('plot', width='1440px', height=f'{900/1600*1440}px')
+                ),
+            )
+        )
+    )
+)
+
+
+def server(input, output, session):
+
+    @reactive.calc
+    @reactive.event(input.pitcher_id, input.date_id)
+    def cached_data():
+
+        year_input = int(input.year_input())
+        sport_id = int(input.level_input())
+        player_input = int(input.pitcher_id())
+        start_date = str(input.date_id()[0])
+        end_date = str(input.date_id()[1])
+        # Simulate an expensive data operation
+        game_list  = scrape.get_player_games_list(sport_id = sport_id,
+                                                season = year_input, 
+                                                player_id = player_input,
+                                                start_date = start_date,
+                                                end_date = end_date,
+                                                game_type = [input.type_input()])
+
+        data_list = scrape.get_data(game_list_input = game_list[:])
+        df = (update.update(scrape.get_data_df(data_list = data_list).filter(
+                            (pl.col("pitcher_id") == player_input)&
+                            (pl.col("is_pitch") == True)
+                            
+
+                            ))).with_columns(
+                pl.col('pitch_type').count().over('pitch_type').alias('pitch_count')
+            )
+        return df
+
+
+    @render.ui
+    @reactive.event(input.player_button, ignore_none=False)
+    def player_select_ui():
+        # Get the list of pitchers for the selected level and season
+        df_pitcher_info = scrape.get_players(sport_id=int(input.level_input()), season=int(input.year_input()), game_type = [input.type_input()]).filter(
+            pl.col("position").is_in(['P','TWP'])).sort("name")
+        
+        # Create a dictionary of pitcher IDs and names
+        pitcher_dict = dict(zip(df_pitcher_info['player_id'], df_pitcher_info['name']))
+        
+        # Return a select input for choosing a pitcher
+        return ui.input_select("pitcher_id", "Select Pitcher", pitcher_dict, selectize=True)
+
+
+    @render.ui
+    @reactive.event(input.pitcher_id, ignore_none=False)
+    def pitch_type_ui():
+        df = cached_data()
+        df = df.clone()
+
+        pitch_dict = dict(zip(df['pitch_type'], df['pitch_description']))
+        return ui.input_select("pitch_type_input", "Select Pitch Type", pitch_dict, selectize=True)
+
+    @render.ui
+    @reactive.event(input.player_button, ignore_none=False)
+    def date_id():
+        # Create a date range input for selecting the date range within the selected year
+        return ui.input_date_range("date_id", "Select Date Range",
+                                   start=f"{int(input.year_input())}-01-01",
+                                   end=f"{int(input.year_input())}-12-31",
+                                   min=f"{int(input.year_input())}-01-01",
+                                    max=f"{int(input.year_input())}-12-31")
+    
+
+
+    @output
+    @render.text
+    def status():
+        # Only show status when generating
+        if input.generate == 0:
+            return ""
+        return ""   
+    
+    @output
+    @render.plot
+    @reactive.event(input.generate_plot, ignore_none=False)   
+    def plot():     
+        # Show progress/loading notification
+        with ui.Progress(min=0, max=1) as p:
+            p.set(message="Generating plot", detail="This may take a while...")
+
+            
+            p.set(0.3, "Gathering data...")
+            year_input = int(input.year_input())
+            sport_id = int(input.level_input())
+            player_input = int(input.pitcher_id())
+            start_date = str(input.date_id()[0])
+            end_date = str(input.date_id()[1])
+            
+
+            print(year_input, sport_id, player_input, start_date, end_date)
+
+            df = cached_data()
+            df = df.clone()
+
+            pitch_input = input.pitch_type_input()
+
+            df_plot = pitch_heat_map(pitch_input, df)
+            pivot_table_l = pitch_prop(df=df_plot, hand = 'L')
+            pivot_table_r = pitch_prop(df=df_plot, hand = 'R')
+
+
+            table_left = df_update().update_summary_select(df=df_plot.filter(pl.col('batter_hand') == 'L'), selection=['pitcher_hand'])
+            table_left = table_left.with_columns(
+                (pl.col('pitches')/len(df.filter(pl.col('batter_hand') == 'L'))).alias('pitch_percent')
+            )
+
+            table_right = df_update().update_summary_select(df=df_plot.filter(pl.col('batter_hand') == 'R'), selection=['pitcher_hand'])
+            table_right = table_right.with_columns(
+                (pl.col('pitches')/len(df.filter(pl.col('batter_hand') == 'R'))).alias('pitch_percent')
+            )
+
+            normalize = mcolors.Normalize(vmin=table_left['pitch_percent']*0.5, 
+                                        vmax=table_left['pitch_percent']*1.5) # Define the range of values
+
+
+            df_colour_left = pd.DataFrame(data=[[get_color(x,normalize,cmap_sum2) for x in pivot_table_l[0]],
+                        [get_color(x,normalize,cmap_sum2) for x in pivot_table_l[1]],
+                        [get_color(x,normalize,cmap_sum2) for x in pivot_table_l[2]]])
+            df_colour_left[0] = '#ffffff'
+
+            normalize = mcolors.Normalize(vmin=table_right['pitch_percent']*0.5, 
+                                        vmax=table_right['pitch_percent']*1.5) # Define the range of values
+
+
+            df_colour_right = pd.DataFrame(data=[[get_color(x,normalize,cmap_sum2) for x in pivot_table_r[0]],
+                        [get_color(x,normalize,cmap_sum2) for x in pivot_table_r[1]],
+                        [get_color(x,normalize,cmap_sum2) for x in pivot_table_r[2]]])
+            df_colour_right[0] = '#ffffff'
+
+
+            table_left = table_left.select(
+                'pitch_percent',
+                'pitches',
+                'heart_zone_percent',
+                'shadow_zone_percent',
+                'chase_zone_percent',
+                'waste_zone_percent',
+                'csw_percent',
+                'whiff_rate',
+                'chase_percent',
+                'bip',
+                'xwoba_percent_contact').to_pandas().T
+
+            table_right = table_right.select(
+                'pitch_percent',
+                'pitches',
+                'heart_zone_percent',
+                'shadow_zone_percent',
+                'chase_zone_percent',
+                'waste_zone_percent',
+                'csw_percent',
+                'whiff_rate',
+                'chase_percent',
+                'bip',
+                'xwoba_percent_contact').to_pandas().T
+
+            table_right = table_right.replace({'nan%':'—'})
+            table_right = table_right.replace({'nan':'—'})
+
+
+
+
+
+            p.set(0.6, "Creating plot...")
+
+            import matplotlib.pyplot as plt
+            fig = plt.figure(figsize=(16, 9))
+            fig.set_facecolor('white')
+            sns.set_theme(style="whitegrid", palette=colour_palette)
+            gs = GridSpec(3, 5,  height_ratios=[2,9,1],width_ratios=[1,9,1,9,1])
+            gs.update(hspace=0.2, wspace=0.3)
+
+            # Add subplots to the grid
+            ax_header = fig.add_subplot(gs[0, :]) 
+            ax_left = fig.add_subplot(gs[1, 1]) 
+            ax_right = fig.add_subplot(gs[1, 3]) 
+
+            axfooter = fig.add_subplot(gs[-1, :])
+
+
+
+            heat_map_plot(df=df_plot, 
+                            ax=ax_left,
+                            cmap=cmap_sum2,
+                            hand='L')
+
+            heat_map_plot(df=df_plot, 
+                            ax=ax_right,
+                            cmap=cmap_sum2,
+                            hand='R')
+
+
+
+            # Load the image
+            img = mpimg.imread('images/left.png')
+            imagebox = OffsetImage(img, zoom=0.58)  # adjust zoom as needed
+            ab = AnnotationBbox(imagebox, (1.25, -0.5), box_alignment=(0, 0), frameon=False)
+            ax_left.add_artist(ab)
+
+
+            # Load the image
+            img = mpimg.imread('images/right.png')
+            imagebox = OffsetImage(img, zoom=0.58)  # adjust zoom as needed
+            # Create an AnnotationBbox
+            ab = AnnotationBbox(imagebox, (-1.25, -0.5), box_alignment=(1, 0), frameon=False)
+
+            ax_right.add_artist(ab)
+
+
+            table_plot(ax=ax_left,
+                        table=table_left,
+                            hand='L')
+
+            table_plot_pivot(ax=ax_left,
+                        pivot_table=pivot_table_l,
+                        df_colour=df_colour_left)
+
+
+            table_plot(ax=ax_right,
+                        table=table_right,
+                            hand='R')
+
+            table_plot_pivot(ax=ax_right,
+                        pivot_table=pivot_table_r,
+                        df_colour=df_colour_right)
+
+
+            from matplotlib.cm import ScalarMappable
+            from matplotlib.colors import Normalize
+            # Create a ScalarMappable with the same colormap and normalization
+            sm = ScalarMappable(cmap=cmap_sum2, norm=Normalize(vmin=0, vmax=1))
+
+            cbar = fig.colorbar(sm, ax=axfooter, orientation='horizontal',aspect=100)
+            cbar.set_ticks([])
+
+            cbar.set_ticks([sm.norm.vmin, sm.norm.vmax])
+
+            cbar.ax.set_xticklabels(['Least', 'Most'])
+            cbar.ax.tick_params(labeltop=True, labelbottom=False, labelsize=14)
+            labels = cbar.ax.get_xticklabels()
+
+            labels[0].set_horizontalalignment('left')
+            labels[-1].set_horizontalalignment('right')
+            labels = cbar.ax.get_xticklabels()
+
+
+            cbar.ax.set_xticklabels(labels)
+            cbar.ax.tick_params(length=0)
+
+
+
+
+
+            axfooter.text(x=0.02,y=1,s='By: Thomas Nestico\n      @TJStats',fontname='Calibri',ha='left',fontsize=18,va='top')
+            axfooter.text(x=1-0.02,y=1,s='Data: MLB',ha='right',fontname='Calibri',fontsize=18,va='top')
+
+            axfooter.axis('off')
+
+            # Display the image on the axis
+            ax_header.set_xlim(-12,12)
+            ax_header.set_ylim(0, 2)
+            ax_header.text(x=0,y=2,s=f"{df_plot['pitcher_name'][0]} - {df_plot['pitcher_hand'][0]}HP\n{df_plot['pitch_description'][0]} Pitch Frequency",ha='center',fontsize=24,va='top')
+            ax_header.text(x=0,y=0.75,s=f"{year_input} {level_dict[str(sport_id)]} Season",ha='center',fontsize=16,va='top')            
+            ax_header.text(x=0,y=0.35,s=f"{df_plot['game_date'][0]} to {df_plot['game_date'][-1]}",ha='center',fontsize=16,va='top',fontstyle='italic')
+
+            ax_header.axis('off')
+
+
+            import urllib
+            import urllib.request
+            import urllib.error
+            from urllib.error import HTTPError
+
+
+            plot_header(pitcher_id=player_input,
+                    ax=ax_header, 
+                    df_team=scrape.get_teams(), 
+                    df_players=scrape.get_players(sport_id,year_input),
+                    sport_id=sport_id,)
+
+
+
+
+
+
+            fig.subplots_adjust(left=0.03, right=0.97, top=0.97, bottom=0.03)
+
+
+    
+
+app = App(app_ui, server)
+
+            
+
+app = App(app_ui, server)

functions/heat_map_functions.py

@@ -39,8 +39,8 @@ label_translation_dict = {
     'pitch_percent': 'Pitch%',
     'pitches': 'Pitches',
     'heart_zone_percent': 'Heart%',
-    'shadow_zone_percent': 'Shado%',
-    'chase_zone_percent': 'Chas%',
+    'shadow_zone_percent': 'Shadow%',
+    'chase_zone_percent': 'Chase%',
     'waste_zone_percent': 'Waste%',
     'csw_percent': 'CSW%',
     'whiff_rate': 'Whiff%',
@@ -160,16 +160,20 @@ def table_plot(ax:plt.Axes,
 
     if hand == 'R':
         bbox_data = Bbox.from_bounds(1.7, -0.5, 2.5, 5)
-        ax.text(s='Against RHH',x=1.7,y=4.65,fontsize=18,fontweight='bold')
-        
+
     else:
         bbox_data = Bbox.from_bounds(-4.2, -0.5, 2.5, 5) # replace width and height with the desired values
-        ax.text(s='Against LHH',x=-3.6,y=4.65,fontsize=18,fontweight='bold')
-        
+    
 
 
     bbox_axes = trans.transform_bbox(bbox_data)
 
+    if hand == 'R':
+        ax.text(s='Against RHH',x=2.95,y=4.65,fontsize=18,fontweight='bold',ha='center')
+    else:
+        ax.text(s='Against LHH',x=-2.95,y=4.65,fontsize=18,fontweight='bold',ha='center')
+    
+
     table = table.apply(lambda x: format_dict[x.name].format(x[0]) if x[0] != '—' else '—', axis=1)
     table.index = [label_translation_dict[x] for x in table.index]
     
@@ -205,7 +209,7 @@ def table_plot_pivot(ax:plt.Axes,
 
     table_plot_pivot = ax.table(cellText=[[format_as_percentage(val) for val in row] for row in pivot_table.select(pivot_table.columns[-4:]).to_numpy()],
                                     colLabels =pivot_table.columns[-4:],
-                                    rowLabels =[' 0 ',' 1 ',' 2 '],
+                                    rowLabels =['  0          ','  1         ','  2          '],
                                     loc='center',
                                     cellLoc='center',
                                     colWidths=[0.3,0.3,0.30,0.3],
@@ -220,8 +224,8 @@ def table_plot_pivot(ax:plt.Axes,
     table_plot_pivot.set_fontsize(min_font_size)
 
 
-    ax.text(x=-1.72, y=5.08, s='Strikes', rotation=90,fontweight='bold')
-    ax.text(x=-1.72, y=5.08, s='Strikes', rotation=90,fontweight='bold')
+    ax.text(x=-1.8, y=5.08, s='Strikes', rotation=90,fontweight='bold')
+    ax.text(x=0, y=6.05, s='Balls',fontweight='bold',ha='center')
 
 
 def plot_header(pitcher_id: str, ax: plt.Axes, df_team: pl.DataFrame, df_players: pl.DataFrame,sport_id:int):

functions/pitch_summary_functions.py

@@ -1055,8 +1055,7 @@ def stat_summary_table(df: pl.DataFrame,
                         player_input: int, 
                         sport_id: int, 
                         ax: plt.Axes,
-                        split: str = 'All',
-                        game_type: list = ['R']):
+                        split: str = 'All'):
     """
     Create a summary table of player statistics.
 
@@ -1073,18 +1072,6 @@ def stat_summary_table(df: pl.DataFrame,
     split : str, optional
         The split type (default is 'All').
     """
-
-    type_dict =  {'R':'Regular Season',
-                   'S':'Spring',
-                   'P':'Playoffs' }
-
-    split_title = {
-        'all':'',
-        'right':' vs RHH',
-        'left':' vs LHH'
-    }
-
-    
     # Format start and end dates
     start_date_format = str(pd.to_datetime(df['game_date'][0]).strftime('%m/%d/%Y'))
     end_date_format = str(pd.to_datetime(df['game_date'][-1]).strftime('%m/%d/%Y'))
@@ -1092,11 +1079,9 @@ def stat_summary_table(df: pl.DataFrame,
     # Determine app context based on sport ID
     appContext = 'majorLeague' if sport_id == 1 else 'minorLeague'
 
-    game_type_str = ','.join([str(x) for x in game_type])
-
     # Fetch player stats from MLB API
     pitcher_stats_call = requests.get(
-        f'https://statsapi.mlb.com/api/v1/people/{player_input}?appContext={appContext}&hydrate=stats(group=[pitching],type=[byDateRange],sportId={sport_id},startDate={start_date_format},endDate={end_date_format},gameType=[{game_type_str}])'
+        f'https://statsapi.mlb.com/api/v1/people/{player_input}?appContext={appContext}&hydrate=stats(group=[pitching],type=[byDateRange],sportId={sport_id},startDate={start_date_format},endDate={end_date_format})'
     ).json()
 
     # Extract stats and create DataFrame
@@ -1118,11 +1103,11 @@ def stat_summary_table(df: pl.DataFrame,
     if df['game_id'][0] == df['game_id'][-1]:
         pitcher_stats_call_df_small = pitcher_stats_call_df.select(['inningsPitched', 'battersFaced', 'earnedRuns', 'hits', 'strikeOuts', 'baseOnBalls', 'hitByPitch', 'homeRuns', 'strikePercentage', 'whiffs'])
         new_column_names = ['$\\bf{IP}$', '$\\bf{PA}$', '$\\bf{ER}$', '$\\bf{H}$', '$\\bf{K}$', '$\\bf{BB}$', '$\\bf{HBP}$', '$\\bf{HR}$', '$\\bf{Strike\%}$', '$\\bf{Whiffs}$']
-        title = f'{df["game_date"][0]} vs {df["batter_team"][0]} ({type_dict[game_type[0]]}){split_title[split]}'
-    elif sport_id != 1 or game_type[0] in ['S','P']:
+        title = f'{df["game_date"][0]} vs {df["batter_team"][0]}'
+    elif sport_id != 1:
         pitcher_stats_call_df_small = pitcher_stats_call_df.select(['inningsPitched', 'battersFaced', 'whip', 'era', 'fip', 'k_percent', 'bb_percent', 'k_bb_percent', 'strikePercentage'])
         new_column_names = ['$\\bf{IP}$', '$\\bf{PA}$', '$\\bf{WHIP}$', '$\\bf{ERA}$', '$\\bf{FIP}$', '$\\bf{K\%}$', '$\\bf{BB\%}$', '$\\bf{K-BB\%}$', '$\\bf{Strike\%}$']
-        title = f'{df["game_date"][0]} to {df["game_date"][-1]} ({type_dict[game_type[0]]}{split_title[split]})'
+        title = f'{df["game_date"][0]} to {df["game_date"][-1]}'
     else:
         fangraphs_table(df=df, ax=ax, player_input=player_input, season=int(df['game_date'][0][0:4]), split=split)
         return
@@ -1136,3 +1121,149 @@ def stat_summary_table(df: pl.DataFrame,
     # Add title to the plot
     ax.text(0.5, 0.9, title, va='bottom', ha='center', fontsize=36, fontstyle='italic')
     ax.axis('off')
+
+
+
+def stat_daily_summary(df: pl.DataFrame,
+                        data: list, 
+                        player_input: int, 
+                        sport_id: int, 
+                        ax: plt.Axes):
+ 
+        
+        pk_list = []
+        pitcher_id_list = []
+        summary_list = []
+        ip_list = []
+        pa_list = []
+        er_list = []
+        hit_list = []
+        k_list = []
+        bb_list = []
+        hbp_list = []
+        strikes_list = []
+        hr_list = []
+        test_list = []
+        game_pk_list = []
+        pitches_list = []
+
+
+        # 'inningsPitched','battersFaced','earnedRuns','hits','strikeOuts','baseOnBalls','hitByPitch'
+
+        for y in range(0,len(data)):
+                
+            pk_list.append([data[y]['gameData']['game']['pk'] for x in data[y]['liveData']['boxscore']['teams']['away']['pitchers']])
+            pk_list.append([data[y]['gameData']['game']['pk'] for x in data[y]['liveData']['boxscore']['teams']['home']['pitchers']])
+
+            pitcher_id_list.append([x for x in data[y]['liveData']['boxscore']['teams']['away']['pitchers']])
+            pitcher_id_list.append([x for x in data[y]['liveData']['boxscore']['teams']['home']['pitchers']])
+
+
+            ip_list.append([data[y]['liveData']['boxscore']['teams']['away']['players']['ID'+str(x)]['stats']['pitching']['inningsPitched'] for x in data[y]['liveData']['boxscore']['teams']['away']['pitchers']])
+            ip_list.append([data[y]['liveData']['boxscore']['teams']['home']['players']['ID'+str(x)]['stats']['pitching']['inningsPitched'] for x in data[y]['liveData']['boxscore']['teams']['home']['pitchers']])
+
+            pa_list.append([data[y]['liveData']['boxscore']['teams']['away']['players']['ID'+str(x)]['stats']['pitching']['battersFaced'] for x in data[y]['liveData']['boxscore']['teams']['away']['pitchers']])
+            pa_list.append([data[y]['liveData']['boxscore']['teams']['home']['players']['ID'+str(x)]['stats']['pitching']['battersFaced'] for x in data[y]['liveData']['boxscore']['teams']['home']['pitchers']])
+
+            er_list.append([data[y]['liveData']['boxscore']['teams']['away']['players']['ID'+str(x)]['stats']['pitching']['earnedRuns'] for x in data[y]['liveData']['boxscore']['teams']['away']['pitchers']])
+            er_list.append([data[y]['liveData']['boxscore']['teams']['home']['players']['ID'+str(x)]['stats']['pitching']['earnedRuns'] for x in data[y]['liveData']['boxscore']['teams']['home']['pitchers']])
+
+            hit_list.append([data[y]['liveData']['boxscore']['teams']['away']['players']['ID'+str(x)]['stats']['pitching']['hits'] for x in data[y]['liveData']['boxscore']['teams']['away']['pitchers']])
+            hit_list.append([data[y]['liveData']['boxscore']['teams']['home']['players']['ID'+str(x)]['stats']['pitching']['hits'] for x in data[y]['liveData']['boxscore']['teams']['home']['pitchers']])
+
+            k_list.append([data[y]['liveData']['boxscore']['teams']['away']['players']['ID'+str(x)]['stats']['pitching']['strikeOuts'] for x in data[y]['liveData']['boxscore']['teams']['away']['pitchers']])
+            k_list.append([data[y]['liveData']['boxscore']['teams']['home']['players']['ID'+str(x)]['stats']['pitching']['strikeOuts'] for x in data[y]['liveData']['boxscore']['teams']['home']['pitchers']])
+
+            bb_list.append([data[y]['liveData']['boxscore']['teams']['away']['players']['ID'+str(x)]['stats']['pitching']['baseOnBalls'] for x in data[y]['liveData']['boxscore']['teams']['away']['pitchers']])
+            bb_list.append([data[y]['liveData']['boxscore']['teams']['home']['players']['ID'+str(x)]['stats']['pitching']['baseOnBalls'] for x in data[y]['liveData']['boxscore']['teams']['home']['pitchers']])
+
+            hbp_list.append([data[y]['liveData']['boxscore']['teams']['away']['players']['ID'+str(x)]['stats']['pitching']['hitByPitch'] for x in data[y]['liveData']['boxscore']['teams']['away']['pitchers']])
+            hbp_list.append([data[y]['liveData']['boxscore']['teams']['home']['players']['ID'+str(x)]['stats']['pitching']['hitByPitch'] for x in data[y]['liveData']['boxscore']['teams']['home']['pitchers']])
+
+            strikes_list.append([data[y]['liveData']['boxscore']['teams']['away']['players']['ID'+str(x)]['stats']['pitching']['strikes'] for x in data[y]['liveData']['boxscore']['teams']['away']['pitchers']])
+            strikes_list.append([data[y]['liveData']['boxscore']['teams']['home']['players']['ID'+str(x)]['stats']['pitching']['strikes'] for x in data[y]['liveData']['boxscore']['teams']['home']['pitchers']])
+
+            pitches_list.append([data[y]['liveData']['boxscore']['teams']['home']['players']['ID'+str(x)]['stats']['pitching']['pitchesThrown'] for x in data[y]['liveData']['boxscore']['teams']['home']['pitchers']])
+            pitches_list.append([data[y]['liveData']['boxscore']['teams']['home']['players']['ID'+str(x)]['stats']['pitching']['pitchesThrown'] for x in data[y]['liveData']['boxscore']['teams']['home']['pitchers']])
+                        
+            
+            hr_list.append([data[y]['liveData']['boxscore']['teams']['away']['players']['ID'+str(x)]['stats']['pitching']['homeRuns'] for x in data[y]['liveData']['boxscore']['teams']['away']['pitchers']])
+            hr_list.append([data[y]['liveData']['boxscore']['teams']['home']['players']['ID'+str(x)]['stats']['pitching']['homeRuns'] for x in data[y]['liveData']['boxscore']['teams']['home']['pitchers']])
+            
+            summary_list.append([data[y]['liveData']['boxscore']['teams']['away']['players']['ID'+str(x)]['stats']['pitching']['summary'] for x in data[y]['liveData']['boxscore']['teams']['away']['pitchers']])
+            summary_list.append([data[y]['liveData']['boxscore']['teams']['home']['players']['ID'+str(x)]['stats']['pitching']['summary'] for x in data[y]['liveData']['boxscore']['teams']['home']['pitchers']])
+
+            test_list.append([x for x in data[y]['liveData']['plays']['allPlays']])
+            game_pk_list.append([data[y]['gameData']['game']['pk'] for x in data[y]['liveData']['plays']['allPlays']])
+
+        flat_list_pk = [item for sublist in pk_list for item in sublist]
+        flat_list_pitcher_id = [item for sublist in pitcher_id_list for item in sublist]
+        flat_list_summary = [item for sublist in summary_list for item in sublist]
+        flat_list_hits = [item for sublist in hit_list for item in sublist]
+        flat_list_k = [item for sublist in k_list for item in sublist]
+        flat_list_bb = [item for sublist in bb_list for item in sublist]
+        flat_list_pa = [item for sublist in pa_list for item in sublist]
+        flat_list_ip = [item for sublist in ip_list for item in sublist]
+        flat_list_hbp= [item for sublist in hbp_list for item in sublist]
+        flat_list_strikes = [item for sublist in strikes_list for item in sublist]
+        flat_list_hr= [item for sublist in hr_list for item in sublist]
+        flat_list_er= [item for sublist in er_list for item in sublist]
+        flat_list_pitches= [item for sublist in pitches_list for item in sublist]
+
+
+
+        pitcher_summary_df = pl.DataFrame(data={'game_id':flat_list_pk,
+                                                'pitcher_id':flat_list_pitcher_id,
+                                                'summary':flat_list_summary,
+                                                'hits':flat_list_hits,
+                                                'k':flat_list_k,
+                                                'bb':flat_list_bb,
+                                                'pa':flat_list_pa,
+                                                'hbp':flat_list_hbp,
+                                                'strikes':flat_list_strikes,
+                                                'hr':flat_list_hr,
+                                                'ip':flat_list_ip,
+                                                'er':flat_list_er,
+                                                'pitches':flat_list_pitches})
+
+
+
+        # Add additional calculated columns
+        pitcher_summary_df = pitcher_summary_df.filter(pl.col('pitcher_id')==player_input).with_columns(
+            pl.lit(df['is_whiff'].sum()).alias('whiffs'),
+            ((pl.col('strikes'))/(pl.col('pitches'))*100).round(1).cast(pl.Utf8).str.concat('%').alias('strikePercentage')
+        )
+
+        # Determine columns and title based on game count and sport ID
+        
+        pitcher_stats_call_df_small = pitcher_summary_df.select(['ip', 
+                                                                    'pa', 
+                                                                    'er', 
+                                                                    'hits', 
+                                                                    'k', 
+                                                                    'bb', 
+                                                                    'hbp', 
+                                                                    'hr', 
+                                                                    'strikePercentage', 
+                                                                    'whiffs'])
+        
+        new_column_names = ['$\\bf{IP}$', '$\\bf{PA}$', '$\\bf{ER}$', '$\\bf{H}$', '$\\bf{K}$', '$\\bf{BB}$', '$\\bf{HBP}$', '$\\bf{HR}$', '$\\bf{Strike\%}$', '$\\bf{Whiffs}$']
+        title = f'{df["game_date"][0]} vs {df["batter_team"][0]}'
+
+        table_fg = ax.table(cellText=pitcher_stats_call_df_small.to_numpy(), colLabels=pitcher_stats_call_df_small.columns, cellLoc='center',
+                        bbox=[0.0, 0.1, 1, 0.7])
+        
+        min_font_size = 20
+        table_fg.set_fontsize(min_font_size)
+
+
+        new_column_names = ['$\\bf{IP}$','$\\bf{PA}$','$\\bf{ER}$','$\\bf{H}$','$\\bf{K}$','$\\bf{BB}$','$\\bf{HBP}$','$\\bf{HR}$','$\\bf{Strike\%}$','$\\bf{Whiffs}$']
+        # #new_column_names = ['Pitch Name', 'Pitch%', 'Velocity', 'Spin Rate','Exit Velocity', 'Whiff%', 'CSW%']
+        for i, col_name in enumerate(new_column_names):
+            table_fg.get_celld()[(0, i)].get_text().set_text(col_name)
+
+        ax.axis('off')
+
+        # Add title to the plot
+        ax.text(0.5, 0.9, title, va='bottom', ha='center', fontsize=36, fontstyle='italic')
+        ax.axis('off')

stuff_model/feature_engineering.py

@@ -51,7 +51,7 @@ def feature_engineering(df: pl.DataFrame) -> pl.DataFrame:
     )
 
     # Define the pitch types to be considered
-    pitch_types = ['SI', 'FF', 'FC']
+    pitch_types = ['SI', 'FF', 'FC','FA']
 
     # Filter the DataFrame to include only the specified pitch types
     df_filtered = df.filter(pl.col('pitch_type').is_in(pitch_types))

stuff_model/tj_stuff_plus_pitch.csv

@@ -9,6 +9,7 @@ FC,98.83449547008738,5.811964883678063,98.54483029899575,83.20928731685326,119.7
 FS,98.25541635267653,6.898952096824192,98.46204303842217,72.25450024197754,114.88400714657823,73.39595959354874,114.78967217449389
 FO,98.15224613640243,1.081819065809178,99.94816563615653,94.0023252668585,100.50624750619224,94.0142169475971,100.50513134245217
 FF,97.29024735737988,6.078459125845886,97.09670890504734,81.2230917971995,118.10419744965911,81.32311771953398,117.7938724746093
+FA,97.29024735737988,6.078459125845886,97.09670890504734,81.2230917971995,118.10419744965911,81.32311771953398,117.7938724746093
 SC,97.27958020025409,1.2452898498180456,97.27958020025409,93.536223938276,101.02293646223218,93.54371065079995,101.01544974970822
 CH,96.35866365133434,6.178939251378385,95.80884625564597,81.28802319264824,121.14136334013493,82.02275793969746,119.09639344796777
 SI,95.14161603816645,4.9734372581529955,95.11657827702109,82.5850956341191,112.99618112461533,82.8856383780296,112.72626192694757