Update functions/pitch_summary_functions.py

functions/pitch_summary_functions.py

@@ -189,12 +189,7 @@ def confidence_ellipse(x, y, ax, n_std=3.0, facecolor='none', **kwargs):
         
     return ax.add_patch(ellipse)     
 ### VELOCITY KDES ###
-def velocity_kdes(df: pl.DataFrame,
-                    ax: plt.Axes,
-                    gs: gridspec.GridSpec,
-                    gs_x: list,
-                    gs_y: list,
-                    fig: plt.Figure):
+def velocity_kdes(df: pl.DataFrame, ax: plt.Axes, gs: gridspec.GridSpec, gs_x: list, gs_y: list, fig: plt.Figure):
     """
     Plot the velocity KDEs for different pitch types.
 
@@ -213,46 +208,30 @@ def velocity_kdes(df: pl.DataFrame,
     fig : plt.Figure
         The figure to plot on.
     """
-    # Join the original DataFrame on 'pitch_type' with sorted counts to reorder
-    items_in_order = (df
-                        .sort("pitch_count", descending=True)['pitch_type']
-                        .unique(maintain_order=True)
-                        .to_numpy()
-                        )
+    # Get unique pitch types sorted by pitch count
+    items_in_order = df.sort("pitch_count", descending=True)['pitch_type'].unique(maintain_order=True).to_numpy()
 
     # Create the inner subplot inside the outer subplot
-    import matplotlib.gridspec as gridspec
     ax.axis('off')
     ax.set_title('Pitch Velocity Distribution', fontdict={'family': 'calibi', 'size': 20})
-
     inner_grid_1 = gridspec.GridSpecFromSubplotSpec(len(items_in_order), 1, subplot_spec=gs[gs_x[0]:gs_x[-1], gs_y[0]:gs_y[-1]])
     ax_top = [fig.add_subplot(inner) for inner in inner_grid_1]
 
     for idx, i in enumerate(items_in_order):
         pitch_data = df.filter(pl.col('pitch_type') == i)['start_speed']
         if np.unique(pitch_data).size == 1:  # Check if all values are the same
-            ax_top[idx].plot([np.unique(pitch_data), np.unique(pitch_data)], [0, 1], linewidth=4,
-                                color=dict_colour[i], zorder=20)
+            ax_top[idx].plot([np.unique(pitch_data), np.unique(pitch_data)], [0, 1], linewidth=4, color=dict_colour[i], zorder=20)
         else:
-            sns.kdeplot(pitch_data, ax=ax_top[idx], fill=True,
-                        clip=(pitch_data.min(), pitch_data.max()),
-                        color=dict_colour[i])
+            sns.kdeplot(pitch_data, ax=ax_top[idx], fill=True, clip=(pitch_data.min(), pitch_data.max()), color=dict_colour[i])
 
         # Plot the mean release speed for the current data
         df_average = df.filter(df['pitch_type'] == i)['start_speed']
-        ax_top[idx].plot([df_average.mean(), df_average.mean()],
-                               [ax_top[idx].get_ylim()[0], ax_top[idx].get_ylim()[1]],
-                               color=dict_colour[i],
-                               linestyle='--')
-        df_statcast_group = pl.read_csv('functions/statcast_2024_grouped.csv')
+        ax_top[idx].plot([df_average.mean(), df_average.mean()], [ax_top[idx].get_ylim()[0], ax_top[idx].get_ylim()[1]], color=dict_colour[i], linestyle='--')
 
         # Plot the mean release speed for the statcast group data
+        df_statcast_group = pl.read_csv('functions/statcast_2024_grouped.csv')
         df_average = df_statcast_group.filter(df_statcast_group['pitch_type'] == i)['release_speed']
-        ax_top[idx].plot([df_average.mean(), df_average.mean()],
-                               [ax_top[idx].get_ylim()[0], ax_top[idx].get_ylim()[1]],
-                               color=dict_colour[i],
-                               linestyle=':')
-
+        ax_top[idx].plot([df_average.mean(), df_average.mean()], [ax_top[idx].get_ylim()[0], ax_top[idx].get_ylim()[1]], color=dict_colour[i], linestyle=':')
 
         ax_top[idx].set_xlim(math.floor(df['start_speed'].min() / 5) * 5, math.ceil(df['start_speed'].max() / 5) * 5)
         ax_top[idx].set_xlabel('')
@@ -266,8 +245,7 @@ def velocity_kdes(df: pl.DataFrame,
         ax_top[idx].set_xticks(range(math.floor(df['start_speed'].min() / 5) * 5, math.ceil(df['start_speed'].max() / 5) * 5, 5))
         ax_top[idx].set_yticks([])
         ax_top[idx].grid(axis='x', linestyle='--')
-        ax_top[idx].text(-0.01, 0.5, i, transform=ax_top[idx].transAxes,
-                            fontsize=14, va='center', ha='right')
+        ax_top[idx].text(-0.01, 0.5, i, transform=ax_top[idx].transAxes, fontsize=14, va='center', ha='right')
 
     ax_top[-1].spines['top'].set_visible(False)
     ax_top[-1].spines['right'].set_visible(False)
@@ -275,7 +253,6 @@ def velocity_kdes(df: pl.DataFrame,
     ax_top[-1].set_xticks(list(range(math.floor(df['start_speed'].min() / 5) * 5, math.ceil(df['start_speed'].max() / 5) * 5, 5)))
     ax_top[-1].set_xlabel('Velocity (mph)')
 
-
 ### TJ STUFF+ ROLLING ###
 def tj_stuff_roling(df: pl.DataFrame, window: int, ax: plt.Axes):
     """
@@ -290,36 +267,29 @@ def tj_stuff_roling(df: pl.DataFrame, window: int, ax: plt.Axes):
     ax : plt.Axes
         The axis to plot on.
     """
-    # Join the original DataFrame on 'pitch_type' with sorted counts to reorder
-    items_in_order = (
-        df.sort("pitch_count", descending=True)['pitch_type']
-        .unique(maintain_order=True)
-        .to_numpy()
-    )
+    # Get unique pitch types sorted by pitch count
+    items_in_order = df.sort("pitch_count", descending=True)['pitch_type'].unique(maintain_order=True).to_numpy()
     
     # Plot the rolling average for each pitch type
     for i in items_in_order:
-        if max(df.filter(pl.col('pitch_type') == i)['pitch_count']) >= window:
-            print('LENGTH',
-                  len(range(1, max(df.filter(pl.col('pitch_type') == i)['pitch_count']) + 1)),
-                  len(df.filter(pl.col('pitch_type') == i)['tj_stuff_plus'].rolling_mean(window)))
+        pitch_data = df.filter(pl.col('pitch_type') == i)
+        if pitch_data['pitch_count'].max() >= window:
             sns.lineplot(
-                x=range(1, max(df.filter(pl.col('pitch_type') == i)['pitch_count']) + 1),
-                y=df.filter(pl.col('pitch_type') == i)['tj_stuff_plus'].rolling_mean(window),
+                x=range(1, pitch_data['pitch_count'].max() + 1),
+                y=pitch_data['tj_stuff_plus'].rolling_mean(window),
                 color=dict_colour[i],
                 ax=ax,
                 linewidth=3
             )
 
     # Adjust x-axis limits to start from 1
-    ax.set_xlim(window, max(df['pitch_count']))
+    ax.set_xlim(window, df['pitch_count'].max())
     ax.set_ylim(70, 130)
     ax.set_xlabel('Pitches', fontdict=font_properties_axes)
     ax.set_ylabel('tjStuff+', fontdict=font_properties_axes)
     ax.set_title(f"{window} Pitch Rolling tjStuff+", fontdict=font_properties_titles)
     ax.xaxis.set_major_locator(MaxNLocator(integer=True))
 
-
 ### TJ STUFF+ ROLLING ###
 def tj_stuff_roling_game(df: pl.DataFrame, window: int, ax: plt.Axes):
     """
@@ -368,15 +338,15 @@ def tj_stuff_roling_game(df: pl.DataFrame, window: int, ax: plt.Axes):
         ])
 
         sns.lineplot(x=range(1, max(df_item['start_number_right']) + 1),
-                     y=df_item.filter(pl.col('pitch_type') == i)['tj_stuff_plus'].rolling_mean(window),
-                     color=dict_colour[i],
-                     ax=ax, linewidth=3)
+                        y=df_item.filter(pl.col('pitch_type') == i)['tj_stuff_plus'].rolling_mean(window),
+                        color=dict_colour[i],
+                        ax=ax, linewidth=3)
 
         # Highlight missing game data points
         for n in range(len(df_item)):
             if df_item['game_id'].is_null()[n]:
                 sns.scatterplot(x=[df_item['start_number_right'][n]],
-                                y=[df_item['tj_stuff_plus'][n]],
+                                y=[df_item['tj_stuff_plus'].rolling_mean(window)[n]],
                                 color='white',
                                 ec='black',
                                 ax=ax,
@@ -390,7 +360,6 @@ def tj_stuff_roling_game(df: pl.DataFrame, window: int, ax: plt.Axes):
     ax.set_title(f"{window} Game Rolling tjStuff+", fontdict=font_properties_titles)
     ax.xaxis.set_major_locator(MaxNLocator(integer=True))
 
-
 def break_plot(df: pl.DataFrame, ax: plt.Axes):
     """
     Plot the pitch breaks for different pitch types.
@@ -416,9 +385,9 @@ def break_plot(df: pl.DataFrame, ax: plt.Axes):
 
     # Plot scatter plot for pitch breaks
     if df['pitcher_hand'][0] == 'R':
-        sns.scatterplot(ax=ax, x=df['hb'], y=df['ivb'] * 1, hue=df['pitch_type'], palette=dict_colour, ec='black', alpha=1, zorder=2)
-    if df['pitcher_hand'][0] == 'L':
-        sns.scatterplot(ax=ax, x=df['hb'], y=df['ivb'] * 1, hue=df['pitch_type'], palette=dict_colour, ec='black', alpha=1, zorder=2)
+        sns.scatterplot(ax=ax, x=df['hb'], y=df['ivb'], hue=df['pitch_type'], palette=dict_colour, ec='black', alpha=1, zorder=2)
+    elif df['pitcher_hand'][0] == 'L':
+        sns.scatterplot(ax=ax, x=df['hb'], y=df['ivb'], hue=df['pitch_type'], palette=dict_colour, ec='black', alpha=1, zorder=2)
 
     # Set axis limits
     ax.set_xlim((-25, 25))
@@ -446,7 +415,7 @@ def break_plot(df: pl.DataFrame, ax: plt.Axes):
                 bbox=dict(facecolor='white', edgecolor='black'), fontsize=12, zorder=3)
         ax.text(24.5, -24.5, s='Arm Side →', fontstyle='italic', ha='right', va='bottom',
                 bbox=dict(facecolor='white', edgecolor='black'), fontsize=12, zorder=3)
-    if df['pitcher_hand'][0] == 'L':
+    elif df['pitcher_hand'][0] == 'L':
         ax.invert_xaxis()
         ax.text(24.5, -24.5, s='← Arm Side', fontstyle='italic', ha='left', va='bottom',
                 bbox=dict(facecolor='white', edgecolor='black'), fontsize=12, zorder=3)
@@ -705,58 +674,81 @@ def summary_table(df: pl.DataFrame, ax: plt.Axes):
                   fancybox=True, loc='lower center', fontsize=20, framealpha=1.0, markerscale=2, prop={'family': 'calibi', 'size': 20})
     ax.axis('off')
 
-def plot_footer(ax:plt.Axes):
-   # Add footer text
+def plot_footer(ax: plt.Axes):
+    """
+    Add footer text to the plot.
+
+    Parameters
+    ----------
+    ax : plt.Axes
+        The axis to add the footer text to.
+    """
+    # Add footer text
     ax.text(0, 1, 'By: @TJStats', ha='left', va='top', fontsize=24)
     ax.text(0.5, 0.25, 
-                '''
-                Colour Coding Compares to League Average By Pitch
-                   tjStuff+ calculates the Expected Run Value (xRV) of a pitch regardless of type
-                   tjStuff+ is normally distributed, where 100 is the mean and Standard Deviation is 10
-                   Pitch Grade scales tjStuff+ to the traditional 20-80 Scouting Scale for a given pitch type
-                   ''', 
-                  ha='center', va='bottom', fontsize=12)
+            '''
+            Colour Coding Compares to League Average By Pitch
+            tjStuff+ calculates the Expected Run Value (xRV) of a pitch regardless of type
+            tjStuff+ is normally distributed, where 100 is the mean and Standard Deviation is 10
+            Pitch Grade scales tjStuff+ to the traditional 20-80 Scouting Scale for a given pitch type
+            ''', 
+            ha='center', va='bottom', fontsize=12)
     ax.text(1, 1, 'Data: MLB, Fangraphs\nImages: MLB, ESPN', ha='right', va='top', fontsize=24)
     ax.axis('off')
 
-
 # Function to get an image from a URL and display it on the given axis
-def player_headshot(player_input: str, ax: plt.Axes, sport_id: int,season: int):
-    # Construct the URL for the player's headshot image
-    print('SPORT ID',sport_id)
+def player_headshot(player_input: str, ax: plt.Axes, sport_id: int, season: int):
+    """
+    Display the player's headshot image on the given axis.
+
+    Parameters
+    ----------
+    player_input : str
+        The player's ID.
+    ax : plt.Axes
+        The axis to display the image on.
+    sport_id : int
+        The sport ID (1 for MLB, other for minor leagues).
+    season : int
+        The season year.
+    """
     try:
+        # Construct the URL for the player's headshot image based on sport ID
         if int(sport_id) == 1:
-            url = f'https://img.mlbstatic.com/mlb-photos/image/'\
-                f'upload/d_people:generic:headshot:67:current.png'\
-                f'/w_640,q_auto:best/v1/people/{player_input}/headshot/silo/current.png'
-
-            # Send a GET request to the URL
-            response = requests.get(url)
-
-            # Open the image from the response content
-            img = Image.open(BytesIO(response.content))
-
-
-            # Display the image on the axis
-            ax.set_xlim(0, 1.3)
-            ax.set_ylim(0, 1)
-            ax.imshow(img, extent=[0, 1, 0, 1], origin='upper')
+            url = f'https://img.mlbstatic.com/mlb-photos/image/upload/d_people:generic:headshot:67:current.png/w_640,q_auto:best/v1/people/{player_input}/headshot/silo/current.png'
         else:
             url = f'https://img.mlbstatic.com/mlb-photos/image/upload/c_fill,g_auto/w_640/v1/people/{player_input}/headshot/milb/current.png'
-            response = requests.get(url)
-            img = Image.open(BytesIO(response.content))
-            ax.set_xlim(0, 1.3)
-            ax.set_ylim(0, 1)
-            ax.imshow(img, extent=[1/6, 5/6, 0, 1], origin='upper')
-    except PIL.UnidentifiedImageError as e:
+
+        # Send a GET request to the URL and open the image from the response content
+        response = requests.get(url)
+        img = Image.open(BytesIO(response.content))
+
+        # Display the image on the axis
+        ax.set_xlim(0, 1.3)
+        ax.set_ylim(0, 1)
+        ax.imshow(img, extent=[0, 1, 0, 1] if sport_id == 1 else [1/6, 5/6, 0, 1], origin='upper')
+    except PIL.UnidentifiedImageError:
         ax.axis('off')
         return
 
     # Turn off the axis
     ax.axis('off')
 
+def player_bio(pitcher_id: str, ax: plt.Axes, sport_id: int, year_input: int):
+    """
+    Display the player's bio information on the given axis.
 
-def player_bio(pitcher_id: str, ax: plt.Axes,sport_id: int,year_input: int):
+    Parameters
+    ----------
+    pitcher_id : str
+        The player's ID.
+    ax : plt.Axes
+        The axis to display the bio information on.
+    sport_id : int
+        The sport ID (1 for MLB, other for minor leagues).
+    year_input : int
+        The season year.
+    """
     # Construct the URL to fetch player data
     url = f"https://statsapi.mlb.com/api/v1/people?personIds={pitcher_id}&hydrate=currentTeam"
 
@@ -782,14 +774,28 @@ def player_bio(pitcher_id: str, ax: plt.Axes,sport_id: int,year_input: int):
     df_sport_id = pl.DataFrame(response['sports'])    
     abb = df_sport_id.filter(pl.col('id') == sport_id)['abbreviation'][0]
 
+    # Display the season and sport abbreviation
     ax.text(0.5, 0.20, f'{year_input} {abb} Season', va='top', ha='center', fontsize=30, fontstyle='italic')
 
     # Turn off the axis
     ax.axis('off')
 
+def plot_logo(pitcher_id: str, ax: plt.Axes, df_team: pl.DataFrame, df_players: pl.DataFrame):
+    """
+    Display the team logo for the given pitcher on the specified axis.
 
-def plot_logo(pitcher_id: str, ax: plt.Axes,df_team: pl.DataFrame,df_players : pl.DataFrame):
-# List of MLB teams and their corresponding ESPN logo URLs
+    Parameters
+    ----------
+    pitcher_id : str
+        The ID of the pitcher.
+    ax : plt.Axes
+        The axis to display the logo on.
+    df_team : pl.DataFrame
+        The DataFrame containing team data.
+    df_players : pl.DataFrame
+        The DataFrame containing player data.
+    """
+    # List of MLB teams and their corresponding ESPN logo URLs
     mlb_teams = [
         {"team": "AZ", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/ari.png&h=500&w=500"},
         {"team": "ATL", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/atl.png&h=500&w=500"},
@@ -823,11 +829,13 @@ def plot_logo(pitcher_id: str, ax: plt.Axes,df_team: pl.DataFrame,df_players : p
         {"team": "WSH", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/wsh.png&h=500&w=500"},
         {"team": "ATH", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/oak.png&h=500&w=500"},
     ]
+
     try:
         # Create a DataFrame from the list of dictionaries
         df_image = pd.DataFrame(mlb_teams)
-        image_dict = df_image.set_index('team')['logo_url'].to_dict()    
-        
+        image_dict = df_image.set_index('team')['logo_url'].to_dict()
+
+        # Get the team ID for the given pitcher
         team_id = df_players.filter(pl.col('player_id') == pitcher_id)['team'][0]
 
         # Construct the URL to fetch team data
@@ -839,8 +847,7 @@ def plot_logo(pitcher_id: str, ax: plt.Axes,df_team: pl.DataFrame,df_players : p
         # Extract the team abbreviation
         if data_team['teams'][0]['id'] in df_team['parent_org_id']:
             team_abb = df_team.filter(pl.col('team_id') == data_team['teams'][0]['id'])['parent_org_abbreviation'][0]
-                                                                                        
-        else:                                                                               
+        else:
             team_abb = df_team.filter(pl.col('parent_org_id') == data_team['teams'][0]['parentOrgId'])['parent_org_abbreviation'][0]
 
         # Get the logo URL from the image dictionary using the team abbreviation
@@ -859,7 +866,7 @@ def plot_logo(pitcher_id: str, ax: plt.Axes,df_team: pl.DataFrame,df_players : p
 
         # Turn off the axis
         ax.axis('off')
-    except KeyError as e:
+    except KeyError:
         ax.axis('off')
         return
 
@@ -910,29 +917,55 @@ def fangraphs_pitching_leaderboards(season: int,
     df = pl.DataFrame(data=data['data'], infer_schema_length=1000)
     return df
 
-def fangrpahs_splits_scrape(player_input: str, year_input: int, start_date: str, end_date: str, split: str):
-    ### FANGRAPHS SPLITS SCRAPE ###
-    split_dict = {'all':[],
-                    'left':['5'],
-                    'right':['6']
-                    }
-    import json
+def fangraphs_splits_scrape(player_input: str, year_input: int, start_date: str, end_date: str, split: str) -> pl.DataFrame:
+    """
+    Scrape Fangraphs splits data for a specific player.
+
+    Parameters
+    ----------
+    player_input : str
+        The player's ID.
+    year_input : int
+        The season year.
+    start_date : str
+        The start date for the data.
+    end_date : str
+        The end date for the data.
+    split : str
+        The split type (e.g., 'all', 'left', 'right').
+
+    Returns
+    -------
+    pl.DataFrame
+        The DataFrame containing the splits data.
+    """
+    split_dict = {
+        'all': [],
+        'left': ['5'],
+        'right': ['6']
+    }
+
+    
+
     url = "https://www.fangraphs.com/api/leaders/splits/splits-leaders"
 
-    fg_id = str(fangraphs_pitching_leaderboards(year_input,
-                                        split='All',
-                                        start_date = f'{year_input}-01-01',
-                                        end_date = f'{year_input}-12-31').filter(pl.col('xMLBAMID')==player_input)['playerid'][0])
-    print('start_date',start_date)
-    print('start_date',end_date)
+    # Get Fangraphs player ID
+    fg_id = str(fangraphs_pitching_leaderboards(
+        year_input,
+        split='All',
+        start_date=f'{year_input}-01-01',
+        end_date=f'{year_input}-12-31'
+    ).filter(pl.col('xMLBAMID') == player_input)['playerid'][0])
+
+    # Payload for basic stats
     payload = {
-        "strPlayerId": str(fg_id),
+        "strPlayerId": fg_id,
         "strSplitArr": split_dict[split],
         "strGroup": "season",
         "strPosition": "P",
         "strType": "2",
-        "strStartDate": str(pd.to_datetime(start_date).strftime('%Y-%m-%d')),
-        "strEndDate": str(pd.to_datetime(end_date).strftime('%Y-%m-%d')),
+        "strStartDate": pd.to_datetime(start_date).strftime('%Y-%m-%d'),
+        "strEndDate": pd.to_datetime(end_date).strftime('%Y-%m-%d'),
         "strSplitTeams": False,
         "dctFilters": [],
         "strStatType": "player",
@@ -945,39 +978,23 @@ def fangrpahs_splits_scrape(player_input: str, year_input: int, start_date: str,
         "arrWxElevation": None,
         "arrWxWindSpeed": None
     }
-    json_payload = json.dumps(payload)
-    headers = {'Content-Type': 'application/json'}
-    response = requests.post(url, data=json_payload, headers=headers)
+
+    # Fetch basic stats
+    response = requests.post(url, data=json.dumps(payload), headers={'Content-Type': 'application/json'})
     data_pull = response.json()['data'][0]
 
-    payload_advanced = {
-        "strPlayerId": str(fg_id),
-        "strSplitArr": split_dict[split],
-        "strGroup": "season",
-        "strPosition": "P",
-        "strType": "1",
-        "strStartDate": str(pd.to_datetime(start_date).strftime('%Y-%m-%d')),
-        "strEndDate": str(pd.to_datetime(end_date).strftime('%Y-%m-%d')),
-        "strSplitTeams": False,
-        "dctFilters": [],
-        "strStatType": "player",
-        "strAutoPt": False,
-        "arrPlayerId": [],
-        "strSplitArrPitch": [],
-        "arrWxTemperature": None,
-        "arrWxPressure": None,
-        "arrWxAirDensity": None,
-        "arrWxElevation": None,
-        "arrWxWindSpeed": None
-    }
+    # Payload for advanced stats
+    payload_advanced = payload.copy()
+    payload_advanced["strType"] = "1"
 
-    json_payload_advanced = json.dumps(payload_advanced)
-    headers = {'Content-Type': 'application/json'}
-    response_advanced = requests.post(url, data=json_payload_advanced, headers=headers)
+    # Fetch advanced stats
+    response_advanced = requests.post(url, data=json.dumps(payload_advanced), headers={'Content-Type': 'application/json'})
     data_pull_advanced = response_advanced.json()['data'][0]
 
+    # Combine basic and advanced stats
     data_pull.update(data_pull_advanced)
     df_pull = pl.DataFrame(data_pull)
+
     return df_pull
 
                                    
@@ -1002,20 +1019,11 @@ def fangraphs_table(df: pl.DataFrame,
     start_date = df['game_date'][0]
     end_date = df['game_date'][-1]
 
-    # Fetch Fangraphs pitching leaderboards data
-    # df_fangraphs = fangraphs_pitching_leaderboards(season=season,
-    #                                                split=split,
-    #                                                start_date=start_date,
-    #                                                end_date=end_date).filter(pl.col('xMLBAMID') == player_input)
-    
-    # df_fangraphs = df_fangraphs.with_columns(
-    #                 ((pl.col('Strikes')/pl.col('Pitches'))).alias('strikePercentage'),
-
-    # )
-    df_fangraphs = fangrpahs_splits_scrape(player_input=player_input, 
+    # Fetch Fangraphs splits data
+    df_fangraphs = fangraphs_splits_scrape(player_input=player_input, 
                                            year_input=season,
                                            start_date=start_date,
-                                           end_date=start_date,
+                                           end_date=end_date,
                                            split=split)
 
     # Select relevant columns for the table
@@ -1044,61 +1052,72 @@ def fangraphs_table(df: pl.DataFrame,
 
 
 def stat_summary_table(df: pl.DataFrame, 
-                  player_input: int, 
-                  sport_id: int, 
-                  ax: plt.Axes,
-                  split: str = 'All'):
+                        player_input: int, 
+                        sport_id: int, 
+                        ax: plt.Axes,
+                        split: str = 'All'):
+    """
+    Create a summary table of player statistics.
+
+    Parameters
+    ----------
+    df : pl.DataFrame
+        The DataFrame containing pitch data.
+    player_input : int
+        The player's ID.
+    sport_id : int
+        The sport ID (1 for MLB, other for minor leagues).
+    ax : plt.Axes
+        The axis to plot the table on.
+    split : str, optional
+        The split type (default is 'All').
+    """
+    # 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'))
 
-    if sport_id == 1:
-        appContext = 'majorLeague'
-    else:
-        appContext = 'minorLeague'
+    # Determine app context based on sport ID
+    appContext = 'majorLeague' if sport_id == 1 else 'minorLeague'
+
+    # 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})'
+    ).json()
 
-    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})').json()
+    # Extract stats and create DataFrame
     pitcher_stats_call_header = [x for x in pitcher_stats_call['people'][0]['stats'][0]['splits'][-1]['stat']]
     pitcher_stats_call_values = [pitcher_stats_call['people'][0]['stats'][0]['splits'][-1]['stat'][x] for x in pitcher_stats_call['people'][0]['stats'][0]['splits'][-1]['stat']]
-    pitcher_stats_call_df = pl.DataFrame(data=dict(zip(pitcher_stats_call_header,pitcher_stats_call_values)))
+    pitcher_stats_call_df = pl.DataFrame(data=dict(zip(pitcher_stats_call_header, pitcher_stats_call_values)))
 
+    # Add additional calculated columns
     pitcher_stats_call_df = pitcher_stats_call_df.with_columns(
         pl.lit(df['is_whiff'].sum()).alias('whiffs'),
-        (pl.col('strikeOuts')/pl.col('battersFaced')*100).round(1).cast(pl.Utf8).str.concat('%').alias('k_percent'),
-        (pl.col('baseOnBalls')/pl.col('battersFaced')*100).round(1).cast(pl.Utf8).str.concat('%').alias('bb_percent'),
-        ((pl.col('strikeOuts') - pl.col('baseOnBalls'))/pl.col('battersFaced')*100).round(1).cast(pl.Utf8).str.concat('%').alias('k_bb_percent'),
-        (((pl.col('homeRuns')*13 + 3*((pl.col('baseOnBalls'))+(pl.col('hitByPitch')))-2*(pl.col('strikeOuts'))))/((pl.col('outs'))/3)+3.15).round(2).map_elements(lambda x: f"{x:.2f}") .alias('fip'),
-        ((pl.col('strikes')/pl.col('numberOfPitches')*100)).round(1).cast(pl.Utf8).str.concat('%').alias('strikePercentage'),
+        (pl.col('strikeOuts') / pl.col('battersFaced') * 100).round(1).cast(pl.Utf8).str.concat('%').alias('k_percent'),
+        (pl.col('baseOnBalls') / pl.col('battersFaced') * 100).round(1).cast(pl.Utf8).str.concat('%').alias('bb_percent'),
+        ((pl.col('strikeOuts') - pl.col('baseOnBalls')) / pl.col('battersFaced') * 100).round(1).cast(pl.Utf8).str.concat('%').alias('k_bb_percent'),
+        (((pl.col('homeRuns') * 13 + 3 * ((pl.col('baseOnBalls')) + (pl.col('hitByPitch'))) - 2 * (pl.col('strikeOuts')))) / ((pl.col('outs')) / 3) + 3.15).round(2).map_elements(lambda x: f"{x:.2f}").alias('fip'),
+        ((pl.col('strikes') / pl.col('numberOfPitches') * 100)).round(1).cast(pl.Utf8).str.concat('%').alias('strikePercentage'),
     )
 
-
+    # Determine columns and title based on game count and sport ID
     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}$']
+        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]}'
     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\%}$']
+        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]}'
     else:
-        fangraphs_table(df=df,
-                        ax=ax,
-                    player_input=player_input,
-                    season=2024,
-                    split=split)
+        fangraphs_table(df=df, ax=ax, player_input=player_input, season=int(df['game_date'][0][0:4]), split=split)
         return
-    
-    import matplotlib.pyplot as plt
-    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 = ['Pitch Name', 'Pitch%', 'Velocity', 'Spin Rate','Exit Velocity', 'Whiff%', 'CSW%']
+    # Create and format the table
+    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])
+    table_fg.set_fontsize(20)
     for i, col_name in enumerate(new_column_names):
         table_fg.get_celld()[(0, i)].get_text().set_text(col_name)
-    
-    ax.text(0.5, 0.9, title, va='bottom', ha='center',
-            fontsize=36, fontstyle='italic')
 
+    # Add title to the plot
+    ax.text(0.5, 0.9, title, va='bottom', ha='center', fontsize=36, fontstyle='italic')
     ax.axis('off')