Upload 23 files

Dockerfile

@@ -1,20 +1,16 @@
 FROM python:3.9
 
-WORKDIR /code
+# Install dependencies
+COPY requirements.txt /app/
+RUN pip install -r /app/requirements.txt
 
-COPY ./requirements.txt /code/requirements.txt
+# Copy app files
+COPY app_name /app/app_name/
+COPY static/ /app/static/
+COPY templates/ /app/templates/
 
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+# Set working directory
+WORKDIR /app/app_name
 
-# Switch to the "user" user
-RUN useradd -m -u 1000 user
-USER user
-ENV HOME=/home/user \
-	PATH=/home/user/.local/bin:$PATH
-
-
-COPY . .
-
-EXPOSE 7860
-
-CMD ["shiny", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]
+# Set the command to run the app
+CMD ["python", "app.py"]

api_scraper.py

@@ -0,0 +1,747 @@
+import requests
+import pandas as pd
+import numpy as np
+from datetime import datetime
+from tqdm import tqdm
+import time
+from pytz import timezone
+
+
+class MLB_Scrape:
+
+    # def __init__(self):
+    #     # Initialize your class here if needed
+    #     pass
+
+    def get_sport_id(self):
+        df = pd.DataFrame(requests.get(url=f'https://statsapi.mlb.com/api/v1/sports').json()['sports']).set_index('id')
+        return df
+
+    def get_sport_id_check(self,sport_id):
+        sport_id_df = self.get_sport_id()
+        if sport_id not in sport_id_df.index:
+            print('Please Select a New Sport ID from the following')
+            print(sport_id_df)
+            return False
+        return True
+
+    def get_schedule(self,year_input=2023,
+                     sport_id=1,
+                     start_date='YYYY-MM-DD',
+                     end_date='YYYY-MM-DD',
+                     final=True,
+                     regular=True,
+                     spring=False):
+        # Get MLB Schedule
+
+        if not self.get_sport_id_check(sport_id=sport_id):
+            return
+        if regular == True:
+            game_call = requests.get(url=f'https://statsapi.mlb.com/api/v1/schedule/?sportId={sport_id}&gameTypes=R&season={year_input}&hydrate=lineup,players').json()
+            print(f'https://statsapi.mlb.com/api/v1/schedule/?sportId={sport_id}&gameTypes=R&season={year_input}&hydrate=lineup,players')
+        elif spring == True:
+            print('spring')
+            game_call = requests.get(url=f'https://statsapi.mlb.com/api/v1/schedule/?sportId={sport_id}&gameTypes=S&season={year_input}&hydrate=lineup,players').json()
+            print(f'https://statsapi.mlb.com/api/v1/schedule/?sportId={sport_id}&gameTypes=S&season={year_input}&hydrate=lineup,players')
+        else:
+            game_call = requests.get(url=f'https://statsapi.mlb.com/api/v1/schedule/?sportId={sport_id}&season={year_input}&hydrate=lineup,players').json()
+
+        # Grab data from MLB Schedule (game id, away, home, state)
+        game_list = [item for sublist in [[y['gamePk'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+        time_list = [item for sublist in [[y['gameDate'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+        date_list = [item for sublist in [[y['officialDate'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+        away_team_list = [item for sublist in [[y['teams']['away']['team']['name'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+        home_team_list = [item for sublist in [[y['teams']['home']['team']['name'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+        state_list = [item for sublist in [[y['status']['codedGameState'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+        venue_id = [item for sublist in [[y['venue']['id'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+        venue_name = [item for sublist in [[y['venue']['name'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+
+        game_df = pd.DataFrame(data={'game_id':game_list,
+                                     'time':time_list,
+                                     'date':date_list,
+                                     'away':away_team_list,
+                                     'home':home_team_list,
+                                     'state':state_list,
+                                     'venue_id':venue_id,
+                                     'venue_name':venue_name})
+
+        # game_list = [item for sublist in [[y['gamePk'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+        # date_list = [item for sublist in [[y['officialDate'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+        # cancel_list = [item for sublist in [[y['status']['codedGameState'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+        # game_df = pd.DataFrame(data={'game_id':game_list,'date':date_list,'state':cancel_list})
+        #game_df = pd.concat([game_df,game_df])
+        if len(game_df) == 0:
+            return 'Schedule Length of 0, please select different parameters.'
+
+        game_df['date'] = pd.to_datetime(game_df['date']).dt.date
+        #game_df['time'] = game_df['time'].dt.tz_localize('UTC')
+        #game_df['time'] = game_df['time'].dt.tz_localize('UTC')
+        game_df['time'] = pd.to_datetime(game_df['time'])
+        eastern = timezone('US/Eastern')
+        game_df['time'] = game_df['time'].dt.tz_convert(eastern)
+        game_df['time'] = game_df['time'].dt.strftime("%I:%M  %p EST")#.dt.time
+
+        if not start_date == 'YYYY-MM-DD' or not end_date == 'YYYY-MM-DD':
+            try:
+                start_date = datetime.strptime(start_date, "%Y-%m-%d").date()
+                end_date = datetime.strptime(end_date, "%Y-%m-%d").date()
+                game_df = game_df[(game_df['date'] >= start_date) & (game_df['date'] <= end_date)]
+
+            except ValueError:
+                return 'Please use YYYY-MM-DD Format for Start and End Dates'
+        if final:
+            game_df = game_df[game_df['state'] == 'F'].drop_duplicates(subset='game_id').reset_index(drop=True)
+
+        game_df = game_df.drop_duplicates(subset='game_id').reset_index(drop=True)
+
+        if len(game_df) == 0:
+            return 'Schedule Length of 0, please select different parameters.'
+
+        return game_df
+
+    def get_data(self,game_list_input = [748540]):
+        data_total = []
+        #n_count = 0
+        print('This May Take a While. Progress Bar shows Completion of Data Retrieval.')
+        for i in tqdm(range(len(game_list_input)), desc="Processing", unit="iteration"):
+        #for game_id_select in game_list:
+            # if n_count%50 == 0:
+            #     print(n_count)
+            r = requests.get(f'https://statsapi.mlb.com/api/v1.1/game/{game_list_input[i]}/feed/live')
+            data_total.append(r.json())
+            #n_count = n_count + 1
+        return data_total
+
+    def get_data_df(self,data_list):
+
+        swing_list = ['X','F','S','D','E','T','W']
+        whiff_list = ['S','T','W']
+        print('Converting Data to Dataframe.')
+        game_id = []
+        game_date = []
+        batter_id = []
+        batter_name = []
+        batter_hand = []
+        batter_team = []
+        batter_team_id = []
+        pitcher_id = []
+        pitcher_name = []
+        pitcher_hand = []
+        pitcher_team = []
+        pitcher_team_id = []
+
+        play_description = []
+        play_code = []
+        in_play = []
+        is_strike = []
+        is_swing = []
+        is_whiff = []
+        is_out = []
+        is_ball = []
+        is_review = []
+        pitch_type = []
+        pitch_description = []
+        strikes = []
+        balls = []
+        outs = []
+
+        start_speed = []
+        end_speed = []
+        sz_top = []
+        sz_bot = []
+        x = []
+        y = []
+        ax = []
+        ay = []
+        az = []
+        pfxx = []
+        pfxz = []
+        px = []
+        pz = []
+        vx0 = []
+        vy0 = []
+        vz0 = []
+        x0 = []
+        y0 = []
+        z0 = []
+        zone = []
+        type_confidence = []
+        plate_time = []
+        extension = []
+        spin_rate = []
+        spin_direction = []
+        ivb = []
+        hb = []
+
+        launch_speed = []
+        launch_angle = []
+        launch_distance = []
+        launch_location = []
+        trajectory = []
+        hardness = []
+        hit_x = []
+        hit_y = []
+
+        index_play = []
+        play_id = []
+        start_time = []
+        end_time = []
+        is_pitch = []
+        type_type = []
+
+
+        type_ab = []
+        ab_number = []
+        event = []
+        event_type = []
+        rbi = []
+        away_score = []
+        home_score = []
+
+#data[0]['liveData']['plays']['allPlays'][32]['playEvents'][-1]['details']['call']['code'] in ['VP']
+
+        for data in data_list:
+            for ab_id in range(len(data['liveData']['plays']['allPlays'])):
+                ab_list = data['liveData']['plays']['allPlays'][ab_id]
+                for n in range(len(ab_list['playEvents'])):
+                    if ab_list['playEvents'][n]['isPitch'] == True or 'call' in ab_list['playEvents'][n]['details']:
+
+                        game_id.append(data['gamePk'])
+                        game_date.append(data['gameData']['datetime']['officialDate'])
+                        if 'matchup' in ab_list:
+                          batter_id.append(ab_list['matchup']['batter']['id'] if 'batter' in ab_list['matchup'] else np.nan)
+                          if 'batter' in ab_list['matchup']:
+                            batter_name.append(ab_list['matchup']['batter']['fullName'] if 'fullName' in ab_list['matchup']['batter'] else np.nan)
+                          else:
+                            batter_name.append(np.nan)
+
+                          batter_hand.append(ab_list['matchup']['batSide']['code'] if 'batSide' in ab_list['matchup'] else np.nan)
+                          pitcher_id.append(ab_list['matchup']['pitcher']['id'] if 'pitcher' in ab_list['matchup'] else np.nan)
+                          if 'pitcher' in ab_list['matchup']:
+                            pitcher_name.append(ab_list['matchup']['pitcher']['fullName'] if 'fullName' in ab_list['matchup']['pitcher'] else np.nan)
+                          else:
+                            pitcher_name.append(np.nan)
+                          #pitcher_name.append(ab_list['matchup']['pitcher']['fullName'] if 'pitcher' in ab_list['matchup'] else np.nan)
+                          pitcher_hand.append(ab_list['matchup']['pitchHand']['code'] if 'pitchHand' in ab_list['matchup'] else np.nan)
+
+
+                        # batter_id.append(ab_list['matchup']['batter']['id'] if 'batter' in ab_list['matchup'] else np.nan)
+                        # batter_name.append(ab_list['matchup']['batter']['fullName'] if 'batter' in ab_list['matchup'] else np.nan)
+                        # batter_hand.append(ab_list['matchup']['batSide']['code'] if 'batSide' in ab_list['matchup'] else np.nan)
+                        # pitcher_id.append(ab_list['matchup']['pitcher']['id'] if 'pitcher' in ab_list['matchup'] else np.nan)
+                        # pitcher_name.append(ab_list['matchup']['pitcher']['fullName'] if 'pitcher' in ab_list['matchup'] else np.nan)
+                        # pitcher_hand.append(ab_list['matchup']['pitchHand']['code'] if 'pitchHand' in ab_list['matchup'] else np.nan)
+
+                        if ab_list['about']['isTopInning']:
+                            batter_team.append(data['gameData']['teams']['away']['abbreviation'] if 'away' in data['gameData']['teams'] else np.nan)
+                            batter_team_id.append(data['gameData']['teams']['away']['id'] if 'away' in data['gameData']['teams'] else np.nan)
+                            pitcher_team.append(data['gameData']['teams']['home']['abbreviation'] if 'home' in data['gameData']['teams'] else np.nan)
+                            pitcher_team_id.append(data['gameData']['teams']['away']['id'] if 'away' in data['gameData']['teams'] else np.nan)
+
+                        else:
+                            batter_team.append(data['gameData']['teams']['home']['abbreviation'] if 'home' in data['gameData']['teams'] else np.nan)
+                            batter_team_id.append(data['gameData']['teams']['home']['id'] if 'home' in data['gameData']['teams'] else np.nan)
+                            pitcher_team.append(data['gameData']['teams']['away']['abbreviation'] if 'away' in data['gameData']['teams'] else np.nan)
+                            pitcher_team_id.append(data['gameData']['teams']['home']['id'] if 'home' in data['gameData']['teams'] else np.nan)
+
+                        play_description.append(ab_list['playEvents'][n]['details']['description'] if 'description' in ab_list['playEvents'][n]['details'] else np.nan)
+                        play_code.append(ab_list['playEvents'][n]['details']['code'] if 'code' in ab_list['playEvents'][n]['details'] else np.nan)
+                        in_play.append(ab_list['playEvents'][n]['details']['isInPlay'] if 'isInPlay' in ab_list['playEvents'][n]['details'] else np.nan)
+                        is_strike.append(ab_list['playEvents'][n]['details']['isStrike'] if 'isStrike' in ab_list['playEvents'][n]['details'] else np.nan)
+
+                        if 'details' in ab_list['playEvents'][n]:
+                            is_swing.append(True if ab_list['playEvents'][n]['details']['code'] in swing_list else np.nan)
+                            is_whiff.append(True if ab_list['playEvents'][n]['details']['code'] in whiff_list else np.nan)
+                        else:
+                            is_swing.append(np.nan)
+                            is_whiff.append(np.nan)
+
+                        #is_out.append(ab_list['playEvents'][n]['details']['isBall'] if 'isBall' in ab_list['playEvents'][n]['details'] else np.nan)
+                        is_ball.append(ab_list['playEvents'][n]['details']['isOut'] if 'isOut' in ab_list['playEvents'][n]['details'] else np.nan)
+                        is_review.append(ab_list['playEvents'][n]['details']['hasReview'] if 'hasReview' in ab_list['playEvents'][n]['details'] else np.nan)
+                        pitch_type.append(ab_list['playEvents'][n]['details']['type']['code'] if 'type' in ab_list['playEvents'][n]['details'] else np.nan)
+                        pitch_description.append(ab_list['playEvents'][n]['details']['type']['description'] if 'type' in ab_list['playEvents'][n]['details'] else np.nan)
+
+                        #if ab_list['playEvents'][n]['isPitch'] == True:
+                        if ab_list['playEvents'][n]['pitchNumber'] == 1:
+                            ab_number.append(ab_list['playEvents'][n]['atBatIndex'] if 'atBatIndex' in ab_list['playEvents'][n] else np.nan)
+                            strikes.append(0)
+                            balls.append(0)
+                            outs.append(0)
+                        else:
+                            ab_number.append(ab_list['playEvents'][n]['atBatIndex'] if 'atBatIndex' in ab_list['playEvents'][n] else np.nan)
+                            strikes.append(ab_list['playEvents'][n-1]['count']['strikes'] if 'strikes' in ab_list['playEvents'][n-1]['count'] else np.nan)
+                            balls.append(ab_list['playEvents'][n-1]['count']['balls'] if 'balls' in ab_list['playEvents'][n-1]['count'] else np.nan)
+                            outs.append(ab_list['playEvents'][n-1]['count']['outs'] if 'outs' in ab_list['playEvents'][n-1]['count'] else np.nan)
+
+                        if 'pitchData' in ab_list['playEvents'][n]:
+
+                            start_speed.append(ab_list['playEvents'][n]['pitchData']['startSpeed'] if 'startSpeed' in ab_list['playEvents'][n]['pitchData'] else np.nan)
+                            end_speed.append(ab_list['playEvents'][n]['pitchData']['endSpeed'] if 'endSpeed' in ab_list['playEvents'][n]['pitchData'] else np.nan)
+
+                            sz_top.append(ab_list['playEvents'][n]['pitchData']['strikeZoneTop'] if 'strikeZoneTop' in ab_list['playEvents'][n]['pitchData'] else np.nan)
+                            sz_bot.append(ab_list['playEvents'][n]['pitchData']['strikeZoneBottom'] if 'strikeZoneBottom' in ab_list['playEvents'][n]['pitchData'] else np.nan)
+                            x.append(ab_list['playEvents'][n]['pitchData']['coordinates']['x'] if 'x' in ab_list['playEvents'][n]['pitchData']['coordinates'] else np.nan)
+                            y.append(ab_list['playEvents'][n]['pitchData']['coordinates']['y'] if 'y' in ab_list['playEvents'][n]['pitchData']['coordinates'] else np.nan)
+
+                            ax.append(ab_list['playEvents'][n]['pitchData']['coordinates']['aX'] if 'aX' in ab_list['playEvents'][n]['pitchData']['coordinates'] else np.nan)
+                            ay.append(ab_list['playEvents'][n]['pitchData']['coordinates']['aY'] if 'aY' in ab_list['playEvents'][n]['pitchData']['coordinates'] else np.nan)
+                            az.append(ab_list['playEvents'][n]['pitchData']['coordinates']['aZ'] if 'aZ' in ab_list['playEvents'][n]['pitchData']['coordinates'] else np.nan)
+                            pfxx.append(ab_list['playEvents'][n]['pitchData']['coordinates']['pfxX'] if 'pfxX' in ab_list['playEvents'][n]['pitchData']['coordinates'] else np.nan)
+                            pfxz.append(ab_list['playEvents'][n]['pitchData']['coordinates']['pfxZ'] if 'pfxZ' in ab_list['playEvents'][n]['pitchData']['coordinates'] else np.nan)
+                            px.append(ab_list['playEvents'][n]['pitchData']['coordinates']['pX'] if 'pX' in ab_list['playEvents'][n]['pitchData']['coordinates'] else np.nan)
+                            pz.append(ab_list['playEvents'][n]['pitchData']['coordinates']['pZ'] if 'pZ' in ab_list['playEvents'][n]['pitchData']['coordinates'] else np.nan)
+                            vx0.append(ab_list['playEvents'][n]['pitchData']['coordinates']['vX0'] if 'vX0' in ab_list['playEvents'][n]['pitchData']['coordinates'] else np.nan)
+                            vy0.append(ab_list['playEvents'][n]['pitchData']['coordinates']['vY0'] if 'vY0' in ab_list['playEvents'][n]['pitchData']['coordinates'] else np.nan)
+                            vz0.append(ab_list['playEvents'][n]['pitchData']['coordinates']['vZ0'] if 'vZ0' in ab_list['playEvents'][n]['pitchData']['coordinates'] else np.nan)
+                            x0.append(ab_list['playEvents'][n]['pitchData']['coordinates']['x0'] if 'x0' in ab_list['playEvents'][n]['pitchData']['coordinates'] else np.nan)
+                            y0.append(ab_list['playEvents'][n]['pitchData']['coordinates']['y0'] if 'y0' in ab_list['playEvents'][n]['pitchData']['coordinates'] else np.nan)
+                            z0.append(ab_list['playEvents'][n]['pitchData']['coordinates']['z0'] if 'z0' in ab_list['playEvents'][n]['pitchData']['coordinates'] else np.nan)
+
+                            zone.append(ab_list['playEvents'][n]['pitchData']['zone'] if 'zone' in ab_list['playEvents'][n]['pitchData'] else np.nan)
+                            type_confidence.append(ab_list['playEvents'][n]['pitchData']['typeConfidence'] if 'typeConfidence' in ab_list['playEvents'][n]['pitchData'] else np.nan)
+                            plate_time.append(ab_list['playEvents'][n]['pitchData']['plateTime'] if 'plateTime' in ab_list['playEvents'][n]['pitchData'] else np.nan)
+                            extension.append(ab_list['playEvents'][n]['pitchData']['extension'] if 'extension' in ab_list['playEvents'][n]['pitchData'] else np.nan)
+
+                            if 'breaks' in ab_list['playEvents'][n]['pitchData']:
+                                spin_rate.append(ab_list['playEvents'][n]['pitchData']['breaks']['spinRate'] if 'spinRate' in ab_list['playEvents'][n]['pitchData']['breaks'] else np.nan)
+                                spin_direction.append(ab_list['playEvents'][n]['pitchData']['breaks']['spinDirection'] if 'spinDirection' in ab_list['playEvents'][n]['pitchData']['breaks'] else np.nan)
+                                ivb.append(ab_list['playEvents'][n]['pitchData']['breaks']['breakVerticalInduced'] if 'breakVerticalInduced' in ab_list['playEvents'][n]['pitchData']['breaks'] else np.nan)
+                                hb.append(ab_list['playEvents'][n]['pitchData']['breaks']['breakHorizontal'] if 'breakHorizontal' in ab_list['playEvents'][n]['pitchData']['breaks'] else np.nan)
+
+                        else:
+                            start_speed.append(np.nan)
+                            end_speed.append(np.nan)
+
+                            sz_top.append(np.nan)
+                            sz_bot.append(np.nan)
+                            x.append(np.nan)
+                            y.append(np.nan)
+
+                            ax.append(np.nan)
+                            ay.append(np.nan)
+                            az.append(np.nan)
+                            pfxx.append(np.nan)
+                            pfxz.append(np.nan)
+                            px.append(np.nan)
+                            pz.append(np.nan)
+                            vx0.append(np.nan)
+                            vy0.append(np.nan)
+                            vz0.append(np.nan)
+                            x0.append(np.nan)
+                            y0.append(np.nan)
+                            z0.append(np.nan)
+
+                            zone.append(np.nan)
+                            type_confidence.append(np.nan)
+                            plate_time.append(np.nan)
+                            extension.append(np.nan)
+                            spin_rate.append(np.nan)
+                            spin_direction.append(np.nan)
+                            ivb.append(np.nan)
+                            hb.append(np.nan)
+
+                        if 'hitData' in ab_list['playEvents'][n]:
+                            launch_speed.append(ab_list['playEvents'][n]['hitData']['launchSpeed'] if 'launchSpeed' in ab_list['playEvents'][n]['hitData'] else np.nan)
+                            launch_angle.append(ab_list['playEvents'][n]['hitData']['launchAngle'] if 'launchAngle' in ab_list['playEvents'][n]['hitData'] else np.nan)
+                            launch_distance.append(ab_list['playEvents'][n]['hitData']['totalDistance'] if 'totalDistance' in ab_list['playEvents'][n]['hitData'] else np.nan)
+                            launch_location.append(ab_list['playEvents'][n]['hitData']['location'] if 'location' in ab_list['playEvents'][n]['hitData'] else np.nan)
+
+                            trajectory.append(ab_list['playEvents'][n]['hitData']['trajectory'] if 'trajectory' in ab_list['playEvents'][n]['hitData'] else np.nan)
+                            hardness.append(ab_list['playEvents'][n]['hitData']['hardness'] if 'hardness' in ab_list['playEvents'][n]['hitData'] else np.nan)
+                            hit_x.append(ab_list['playEvents'][n]['hitData']['coordinates']['coordX'] if 'coordX' in ab_list['playEvents'][n]['hitData']['coordinates'] else np.nan)
+                            hit_y.append(ab_list['playEvents'][n]['hitData']['coordinates']['coordY'] if 'coordY' in ab_list['playEvents'][n]['hitData']['coordinates'] else np.nan)
+                        else:
+                            launch_speed.append(np.nan)
+                            launch_angle.append(np.nan)
+                            launch_distance.append(np.nan)
+                            launch_location.append(np.nan)
+                            trajectory.append(np.nan)
+                            hardness.append(np.nan)
+                            hit_x.append(np.nan)
+                            hit_y.append(np.nan)
+
+                        index_play.append(ab_list['playEvents'][n]['index'] if 'index' in ab_list['playEvents'][n] else np.nan)
+                        play_id.append(ab_list['playEvents'][n]['playId'] if 'playId' in ab_list['playEvents'][n] else np.nan)
+                        start_time.append(ab_list['playEvents'][n]['startTime'] if 'startTime' in ab_list['playEvents'][n] else np.nan)
+                        end_time.append(ab_list['playEvents'][n]['endTime'] if 'endTime' in ab_list['playEvents'][n] else np.nan)
+                        is_pitch.append(ab_list['playEvents'][n]['isPitch'] if 'isPitch' in ab_list['playEvents'][n] else np.nan)
+                        type_type.append(ab_list['playEvents'][n]['type'] if 'type' in ab_list['playEvents'][n] else np.nan)
+
+
+
+                        if n == len(ab_list['playEvents']) - 1 :
+
+                            type_ab.append(data['liveData']['plays']['allPlays'][ab_id]['result']['type'] if 'type' in data['liveData']['plays']['allPlays'][ab_id]['result'] else np.nan)
+                            event.append(data['liveData']['plays']['allPlays'][ab_id]['result']['event'] if 'event' in data['liveData']['plays']['allPlays'][ab_id]['result'] else np.nan)
+                            event_type.append(data['liveData']['plays']['allPlays'][ab_id]['result']['eventType'] if 'eventType' in data['liveData']['plays']['allPlays'][ab_id]['result'] else np.nan)
+                            rbi.append(data['liveData']['plays']['allPlays'][ab_id]['result']['rbi'] if 'rbi' in data['liveData']['plays']['allPlays'][ab_id]['result'] else np.nan)
+                            away_score.append(data['liveData']['plays']['allPlays'][ab_id]['result']['awayScore'] if 'awayScore' in data['liveData']['plays']['allPlays'][ab_id]['result'] else np.nan)
+                            home_score.append(data['liveData']['plays']['allPlays'][ab_id]['result']['homeScore'] if 'homeScore' in data['liveData']['plays']['allPlays'][ab_id]['result'] else np.nan)
+                            is_out.append(data['liveData']['plays']['allPlays'][ab_id]['result']['isOut'] if 'isOut' in data['liveData']['plays']['allPlays'][ab_id]['result'] else np.nan)
+
+                        else:
+
+                            type_ab.append(np.nan)
+                            event.append(np.nan)
+                            event_type.append(np.nan)
+                            rbi.append(np.nan)
+                            away_score.append(np.nan)
+                            home_score.append(np.nan)
+                            is_out.append(np.nan)
+
+                    elif ab_list['playEvents'][n]['count']['balls'] == 4:
+
+                        event.append(data['liveData']['plays']['allPlays'][ab_id]['result']['event'])
+                        event_type.append(data['liveData']['plays']['allPlays'][ab_id]['result']['eventType'])
+
+
+                        game_id.append(data['gamePk'])
+                        game_date.append(data['gameData']['datetime']['officialDate'])
+                        batter_id.append(ab_list['matchup']['batter']['id'] if 'batter' in ab_list['matchup'] else np.nan)
+                        batter_name.append(ab_list['matchup']['batter']['fullName'] if 'batter' in ab_list['matchup'] else np.nan)
+                        batter_hand.append(ab_list['matchup']['batSide']['code'] if 'batSide' in ab_list['matchup'] else np.nan)
+                        pitcher_id.append(ab_list['matchup']['pitcher']['id'] if 'pitcher' in ab_list['matchup'] else np.nan)
+                        pitcher_name.append(ab_list['matchup']['pitcher']['fullName'] if 'pitcher' in ab_list['matchup'] else np.nan)
+                        pitcher_hand.append(ab_list['matchup']['pitchHand']['code'] if 'pitchHand' in ab_list['matchup'] else np.nan)
+                        if ab_list['about']['isTopInning']:
+                            batter_team.append(data['gameData']['teams']['away']['abbreviation'] if 'away' in data['gameData']['teams'] else np.nan)
+                            batter_team_id.append(data['gameData']['teams']['away']['id'] if 'away' in data['gameData']['teams'] else np.nan)
+                            pitcher_team.append(data['gameData']['teams']['home']['abbreviation'] if 'home' in data['gameData']['teams'] else np.nan)
+                            pitcher_team_id.append(data['gameData']['teams']['away']['id'] if 'away' in data['gameData']['teams'] else np.nan)
+                        else:
+                            batter_team.append(data['gameData']['teams']['home']['abbreviation'] if 'home' in data['gameData']['teams'] else np.nan)
+                            batter_team_id.append(data['gameData']['teams']['home']['id'] if 'home' in data['gameData']['teams'] else np.nan)
+                            pitcher_team.append(data['gameData']['teams']['away']['abbreviation'] if 'away' in data['gameData']['teams'] else np.nan)
+                            pitcher_team_id.append(data['gameData']['teams']['home']['id'] if 'home' in data['gameData']['teams'] else np.nan)
+
+                        play_description.append(np.nan)
+                        play_code.append(np.nan)
+                        in_play.append(np.nan)
+                        is_strike.append(np.nan)
+                        is_ball.append(np.nan)
+                        is_review.append(np.nan)
+                        pitch_type.append(np.nan)
+                        pitch_description.append(np.nan)
+                        strikes.append(ab_list['playEvents'][n]['count']['balls'] if 'balls' in ab_list['playEvents'][n]['count'] else np.nan)
+                        balls.append(ab_list['playEvents'][n]['count']['strikes'] if 'strikes' in ab_list['playEvents'][n]['count'] else np.nan)
+                        outs.append(ab_list['playEvents'][n]['count']['outs'] if 'outs' in ab_list['playEvents'][n]['count'] else np.nan)
+                        index_play.append(ab_list['playEvents'][n]['index'] if 'index' in ab_list['playEvents'][n] else np.nan)
+                        play_id.append(ab_list['playEvents'][n]['playId'] if 'playId' in ab_list['playEvents'][n] else np.nan)
+                        start_time.append(ab_list['playEvents'][n]['startTime'] if 'startTime' in ab_list['playEvents'][n] else np.nan)
+                        end_time.append(ab_list['playEvents'][n]['endTime'] if 'endTime' in ab_list['playEvents'][n] else np.nan)
+                        is_pitch.append(ab_list['playEvents'][n]['isPitch'] if 'isPitch' in ab_list['playEvents'][n] else np.nan)
+                        type_type.append(ab_list['playEvents'][n]['type'] if 'type' in ab_list['playEvents'][n] else np.nan)
+
+
+
+                        is_swing.append(np.nan)
+                        is_whiff.append(np.nan)
+                        start_speed.append(np.nan)
+                        end_speed.append(np.nan)
+                        sz_top.append(np.nan)
+                        sz_bot.append(np.nan)
+                        x.append(np.nan)
+                        y.append(np.nan)
+                        ax.append(np.nan)
+                        ay.append(np.nan)
+                        az.append(np.nan)
+                        pfxx.append(np.nan)
+                        pfxz.append(np.nan)
+                        px.append(np.nan)
+                        pz.append(np.nan)
+                        vx0.append(np.nan)
+                        vy0.append(np.nan)
+                        vz0.append(np.nan)
+                        x0.append(np.nan)
+                        y0.append(np.nan)
+                        z0.append(np.nan)
+                        zone.append(np.nan)
+                        type_confidence.append(np.nan)
+                        plate_time.append(np.nan)
+                        extension.append(np.nan)
+                        spin_rate.append(np.nan)
+                        spin_direction.append(np.nan)
+                        ivb.append(np.nan)
+                        hb.append(np.nan)
+                        launch_speed.append(np.nan)
+                        launch_angle.append(np.nan)
+                        launch_distance.append(np.nan)
+                        launch_location.append(np.nan)
+                        trajectory.append(np.nan)
+                        hardness.append(np.nan)
+                        hit_x.append(np.nan)
+                        hit_y.append(np.nan)
+                        type_ab.append(np.nan)
+                        ab_number.append(np.nan)
+
+                        rbi.append(np.nan)
+                        away_score.append(np.nan)
+                        home_score.append(np.nan)
+                        is_out.append(np.nan)
+        print({
+            'game_id':len(game_id),
+            'game_date':len(game_date),
+            'batter_id':len(batter_id),
+            'batter_name':len(batter_name),
+            'batter_hand':len(batter_hand),
+            'batter_team':len(batter_team),
+            'batter_team_id':len(batter_team_id),
+            'pitcher_id':len(pitcher_id),
+            'pitcher_name':len(pitcher_name),
+            'pitcher_hand':len(pitcher_hand),
+            'pitcher_team':len(pitcher_team),
+            'pitcher_team_id':len(pitcher_team_id),
+            'play_description':len(play_description),
+            'play_code':len(play_code),
+            'in_play':len(in_play),
+            'is_strike':len(is_strike),
+            'is_swing':len(is_swing),
+            'is_whiff':len(is_whiff),
+            'is_out':len(is_out),
+            'is_ball':len(is_ball),
+            'is_review':len(is_review),
+            'pitch_type':len(pitch_type),
+            'pitch_description':len(pitch_description),
+            'strikes':len(strikes),
+            'balls':len(balls),
+            'outs':len(outs),
+            'start_speed':len(start_speed),
+            'end_speed':len(end_speed),
+            'sz_top':len(sz_top),
+            'sz_bot':len(sz_bot),
+            'x':len(x),
+            'y':len(y),
+            'ax':len(ax),
+            'ay':len(ay),
+            'az':len(az),
+            'pfxx':len(pfxx),
+            'pfxz':len(pfxz),
+            'px':len(px),
+            'pz':len(pz),
+            'vx0':len(vx0),
+            'vy0':len(vy0),
+            'vz0':len(vz0),
+            'x0':len(x0),
+            'y0':len(y0),
+            'z0':len(z0),
+            'zone':len(zone),
+            'type_confidence':len(type_confidence),
+            'plate_time':len(plate_time),
+            'extension':len(extension),
+            'spin_rate':len(spin_rate),
+            'spin_direction':len(spin_direction),
+            'ivb':len(ivb),
+            'hb':len(hb),
+            'launch_speed':len(launch_speed),
+            'launch_angle':len(launch_angle),
+            'launch_distance':len(launch_distance),
+            'launch_location':len(launch_location),
+            'trajectory':len(trajectory),
+            'hardness':len(hardness),
+            'hit_x':len(hit_x),
+            'hit_y':len(hit_y),
+            'index_play':len(index_play),
+            'play_id':len(play_id),
+            'start_time':len(start_time),
+            'end_time':len(end_time),
+            'is_pitch':len(is_pitch),
+            'type_type':len(type_type),
+            'type_ab':len(type_ab),
+            'event':len(event),
+            'event_type':len(event_type),
+            'rbi':len(rbi),
+            'away_score':len(away_score),
+            'home_score':len(home_score),
+            }
+
+
+        )
+        df  = pd.DataFrame(data={
+            'game_id':game_id,
+            'game_date':game_date,
+            'batter_id':batter_id,
+            'batter_name':batter_name,
+            'batter_hand':batter_hand,
+            'batter_team':batter_team,
+            'batter_team_id':batter_team_id,
+            'pitcher_id':pitcher_id,
+            'pitcher_name':pitcher_name,
+            'pitcher_hand':pitcher_hand,
+            'pitcher_team':pitcher_team,
+            'pitcher_team_id':pitcher_team_id,
+            'play_description':play_description,
+            'play_code':play_code,
+            'in_play':in_play,
+            'is_strike':is_strike,
+            'is_swing':is_swing,
+            'is_whiff':is_whiff,
+            'is_out':is_out,
+            'is_ball':is_ball,
+            'is_review':is_review,
+            'pitch_type':pitch_type,
+            'pitch_description':pitch_description,
+            'strikes':strikes,
+            'balls':balls,
+            'outs':outs,
+            'start_speed':start_speed,
+            'end_speed':end_speed,
+            'sz_top':sz_top,
+            'sz_bot':sz_bot,
+            'x':x,
+            'y':y,
+            'ax':ax,
+            'ay':ay,
+            'az':az,
+            'pfxx':pfxx,
+            'pfxz':pfxz,
+            'px':px,
+            'pz':pz,
+            'vx0':vx0,
+            'vy0':vy0,
+            'vz0':vz0,
+            'x0':x0,
+            'y0':y0,
+            'z0':z0,
+            'zone':zone,
+            'type_confidence':type_confidence,
+            'plate_time':plate_time,
+            'extension':extension,
+            'spin_rate':spin_rate,
+            'spin_direction':spin_direction,
+            'ivb':ivb,
+            'hb':hb,
+            'launch_speed':launch_speed,
+            'launch_angle':launch_angle,
+            'launch_distance':launch_distance,
+            'launch_location':launch_location,
+            'trajectory':trajectory,
+            'hardness':hardness,
+            'hit_x':hit_x,
+            'hit_y':hit_y,
+            'index_play':index_play,
+            'play_id':play_id,
+            'start_time':start_time,
+            'end_time':end_time,
+            'is_pitch':is_pitch,
+            'type_type':type_type,
+            'type_ab':type_ab,
+            'event':event,
+            'event_type':event_type,
+            'rbi':rbi,
+            'away_score':away_score,
+            'home_score':home_score,
+
+            }
+            )
+        return df
+
+    def get_players(self,sport_id=1):
+        player_data = requests.get(url=f'https://statsapi.mlb.com/api/v1/sports/{sport_id}/players').json()
+
+        #Select relevant data that will help distinguish players from one another
+        fullName_list = [x['fullName'] for x in player_data['people']]
+        id_list = [x['id'] for x in player_data['people']]
+        position_list = [x['primaryPosition']['abbreviation'] for x in player_data['people']]
+        team_list = [x['currentTeam']['id']for x in player_data['people']]
+        age_list = [x['currentAge']for x in player_data['people']]
+
+        player_df = pd.DataFrame(data={'player_id':id_list,
+                        'name':fullName_list,
+                        'position':position_list,
+                        'team':team_list,
+                        'age':age_list})
+        return player_df
+
+    def get_teams(self):
+        teams =  requests.get(url='https://statsapi.mlb.com/api/v1/teams/').json()
+        #Select only teams that are at the MLB level
+        # mlb_teams_city = [x['franchiseName'] for x in teams['teams'] if x['sport']['name'] == 'Major League Baseball']
+        # mlb_teams_name = [x['teamName'] for x in teams['teams'] if x['sport']['name'] == 'Major League Baseball']
+        # mlb_teams_franchise = [x['name'] for x in teams['teams'] if x['sport']['name'] == 'Major League Baseball']
+        # mlb_teams_id = [x['id'] for x in teams['teams'] if x['sport']['name'] == 'Major League Baseball']
+        # mlb_teams_abb = [x['abbreviation'] for x in teams['teams'] if x['sport']['name'] == 'Major League Baseball']
+
+        mlb_teams_city = [x['franchiseName']  if 'franchiseName' in x else None for x in teams['teams']]
+        mlb_teams_name = [x['teamName']  if 'franchiseName' in x else None for x in teams['teams']]
+        mlb_teams_franchise = [x['name']  if 'franchiseName' in x else None for x in teams['teams']]
+        mlb_teams_id = [x['id']  if 'franchiseName' in x else None for x in teams['teams']]
+        mlb_teams_abb = [x['abbreviation']  if 'franchiseName' in x else None for x in teams['teams']]
+        mlb_teams_parent_id = [x['parentOrgId']  if 'parentOrgId' in x else None for x in teams['teams']]
+        mlb_teams_parent = [x['parentOrgName']  if 'parentOrgName' in x else None for x in teams['teams']]
+        mlb_teams_league_id = [x['league']['id']  if 'id' in x['league'] else None for x in teams['teams']]
+        mlb_teams_league_name = [x['league']['name']  if 'name' in x['league'] else None for x in teams['teams']]
+
+
+
+        #Create a dataframe of all the teams
+        mlb_teams_df = pd.DataFrame(data={'team_id':mlb_teams_id,
+                                          'city':mlb_teams_franchise,
+                                          'name':mlb_teams_name,
+                                          'franchise':mlb_teams_franchise,
+                                          'abbreviation':mlb_teams_abb,
+                                          'parent_org_id':mlb_teams_parent_id,
+                                          'parent_org':mlb_teams_parent,
+                                          'league_id':mlb_teams_league_id,
+                                          'league_name':mlb_teams_league_name
+
+                                          }).drop_duplicates().dropna(subset=['team_id']).reset_index(drop=True).sort_values('team_id')
+
+        mlb_teams_df.loc[mlb_teams_df['parent_org_id'].isnull(),'parent_org_id'] = mlb_teams_df.loc[mlb_teams_df['parent_org_id'].isnull(),'team_id']
+        mlb_teams_df.loc[mlb_teams_df['parent_org'].isnull(),'parent_org'] = mlb_teams_df.loc[mlb_teams_df['parent_org'].isnull(),'franchise']
+
+
+        mlb_teams_df['parent_org_abbreviation'] = mlb_teams_df['parent_org_id'].map(mlb_teams_df.set_index('team_id')['abbreviation'].to_dict())
+
+
+        #mlb_teams_df.loc[mlb_teams_df.franchise.isin(mlb_teams_df.parent_org.unique()),'parent_org'] = mlb_teams_df.loc[mlb_teams_df.franchise.isin(mlb_teams_df.parent_org.unique()),'franchise']
+
+        return mlb_teams_df
+
+    def get_leagues(self):
+        leagues = requests.get(url='https://statsapi.mlb.com/api/v1/leagues/').json()
+
+        sport_id = [x['sport']['id'] if 'sport' in x else None for x in leagues['leagues']]
+        league_id = [x['id']  if 'id' in x else None for x in leagues['leagues']]
+        league_name = [x['name']  if 'name' in x else None for x in leagues['leagues']]
+        league_abbreviation = [x['abbreviation']  if 'abbreviation' in x else None for x in leagues['leagues']]
+
+
+
+        leagues_df = pd.DataFrame(data= {
+                                    'league_id':league_id,
+                                    'league_name':league_name,
+                                    'league_abbreviation':league_abbreviation,
+                                    'sport_id':sport_id,
+                                    })
+
+        return leagues_df
+
+    def get_player_games_list(self,player_id=691587):
+        player_game_list = [x['game']['gamePk'] for x in requests.get(url=f'http://statsapi.mlb.com/api/v1/people/{player_id}?hydrate=stats(type=gameLog,season=2023),hydrations').json()['people'][0]['stats'][0]['splits']]
+        return player_game_list
+
+    def get_team_schedule(self,year=2023,sport_id=1,mlb_team='Toronto Blue Jays'):
+        if not self.get_sport_id_check(sport_id=sport_id):
+            print('Please Select a New Sport ID from the following')
+            print(self.get_sport_id())
+            return False, False
+
+        schedule_df = self.get_schedule(year_input=year,sport_id=sport_id)
+        teams_df = self.get_teams().merge(self.get_leagues()).merge(self.get_sport_id(),left_on=['sport_id'],right_index=True,suffixes=['','_sport'])
+        teams_df = teams_df[teams_df['sport_id'] == sport_id]
+        team_abb_select = teams_df[teams_df['parent_org'] == mlb_team]['abbreviation'].values[0]
+        team_name_select = teams_df[teams_df['parent_org'] == mlb_team]['franchise'].values[0]
+        schedule_df = schedule_df[((schedule_df.away == team_name_select) | (schedule_df.home == team_name_select)) & (schedule_df.state == 'F')].reset_index(drop=True)
+        return schedule_df,teams_df
+
+    def get_team_game_data(self,year=2023,sport_id=1,mlb_team='Toronto Blue Jays'):
+        schedule_df,teams_df = self.get_team_schedule(year=year,sport_id=sport_id,mlb_team=mlb_team)
+        if not schedule_df:
+            return
+        data = self.get_data(schedule_df['game_id'][:])
+        df = self.get_data_df(data_list = data)
+        df['mlb_team'] = teams_df[teams_df['parent_org'] == mlb_team]['parent_org_abbreviation'].values[0]
+        df['level'] = teams_df[teams_df['parent_org'] == mlb_team]['abbreviation_sport'].values[0]
+
+        return df

app.py

@@ -1,551 +1,779 @@
-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 joblib
+import matplotlib.pyplot as plt
+import seaborn as sns
+import pitch_summary_functions as psf
+import requests
+import matplotlib
+from api_scraper import MLB_Scrape
+
+
+
+colour_palette = ['#FFB000','#648FFF','#785EF0',
+                  '#DC267F','#FE6100','#3D1EB2','#894D80','#16AA02','#B5592B','#A3C1ED']
+
+df_2024 = pd.read_csv('C:/Users/thoma/Google Drive/Python/Baseball/season_stats/2024/2024_regular_data.csv',index_col=[0])
+df_2024 = df_2024.drop_duplicates(subset=['play_id'],keep='last')
+
+# ### Import Datasets
+# import datasets
+# from datasets import load_dataset
+# dataset = load_dataset('nesticot/mlb_data', data_files=['mlb_pitch_data_2020.csv' ])
+# dataset_train = dataset['train']
+# df_2024 = dataset_train.to_pandas().set_index(list(dataset_train.features.keys())[0]).reset_index(drop=True)
+
+### PITCH COLOURS ###
+pitch_colours = {
+        'Four-Seam Fastball':'#FF007D',#BC136F
+        'Sinker':'#98165D',#DC267F
+        'Cutter':'#BE5FA0',
+
+        'Changeup':'#F79E70',#F75233
+        'Splitter':'#FE6100',#F75233
+        'Screwball':'#F08223',
+        'Forkball':'#FFB000',
+        
+        'Slider':'#67E18D',#1BB999#785EF0
+        'Sweeper':'#1BB999',#37CD85#904039
+        'Slurve':'#376748',#785EF0#549C07#BEABD8
 
-import datasets
-from datasets import load_dataset
-dataset = load_dataset('nesticot/mlb_data', data_files=['mlb_pitch_data_2024_spring.csv'])
-dataset_train = dataset['train']
-df_2024 = dataset_train.to_pandas().set_index(list(dataset_train.features.keys())[0]).reset_index(drop=True)
+        'Knuckle Curve':'#311D8B',  
+        'Curveball':'#3025CE',
+        'Slow Curve':'#274BFC',
+        'Eephus':'#648FFF',
 
+        'Knuckleball':'#867A08',
+
+        'Pitch Out':'#472C30',
+        'Other':'#9C8975',
+        }
 
-# 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()
 
+season_start = '2024-03-20'
+season_end = '2024-09-29'
+season_fg=2024 
+chad_fg = requests.get(f'https://www.fangraphs.com/api/leaders/major-league/data?age=&pos=all&stats=pit&lg=all&qual=0&season={season_fg}&season={season_fg}&month=1000&season1={season_fg}&ind=0&pageitems=2000000000&pagenum=1&ind=0&rost=0&players=&type=36&postseason=&sortdir=default&sortstat=sp_pitching').json()
 
-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])
+chadwick_df_small = pd.DataFrame(data={
+'key_mlbam':[x['xMLBAMID'] for x in chad_fg['data']],
+'key_fangraphs':[x['playerid'] for x in chad_fg['data']],
+'Name':[x['PlayerName'] for x in chad_fg['data']],
+})    
 
-model = joblib.load('tjstuff_model_20240123.joblib')
+pitcher_dicts = chadwick_df_small.set_index('key_mlbam')['Name'].sort_values().to_dict()
+mlb_fg_dicts = chadwick_df_small.set_index('key_mlbam')['key_fangraphs'].sort_values().to_dict()
 
 
-def percentile(n):
-    def percentile_(x):
-        return x.quantile(n)
-    percentile_.__name__ = 'percentile_{:02.0f}'.format(n*100)
-    return percentile_
+statcast_pitch_summary = pd.read_csv('statcast_pitch_summary.csv')
+cmap_sum = matplotlib.colors.LinearSegmentedColormap.from_list("", ['#648FFF','#FFFFFF','#FFB000',])
 
-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_2024_codes = psf.df_update_code(df_2024)
 
-    # 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_2024_update = psf.df_clean(df_2024_codes)
+import joblib
+model = joblib.load('joblib_model/tjstuff_model_20240318.joblib')
+y_pred_mean = 0.0011434511
+y_pred_std = 0.006554768
+
+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_2024_update['y_pred'] = model.predict(df_2024_update[features])
+
+df_2024_update['tj_stuff_plus'] = 100 + 10*((-df_2024_update.y_pred +y_pred_mean) / y_pred_std)
+
+team_logos = pd.read_csv('team_logos.csv')
+
+mlb_stats = MLB_Scrape()
+teams_df = mlb_stats.get_teams()
+team_logo_dict = teams_df.set_index(['team_id'])['parent_org_id'].to_dict()
+
+font_properties = {'family': 'calibi', 'size': 12}
+font_properties_titles = {'family': 'calibi', 'size': 20}
+font_properties_axes = {'family': 'calibi', 'size': 16}
+df_plot = []
+ax2_loc = []
+gs = []
+fig = []
+
+function_dict={
+    'velocity_kde':'Velocity Distributions',
+    'break_plot':'Pitch Movement',
+    'rolling_tj_stuff':'Rolling tjStuff+',
+    'location_lhb':'Locations vs LHB',
+    'location_rhb':'Locations vs RHB',
+}
+
+split_dict =  {'all':'All',
+               'left':'LHB',
+               'right':'RHB'}
+
+split_dict_hand =  {'all':['L','R'],
+               'left':['L'],
+               'right':['R']}
+
+ball_dict =  {'0':'0',
+               '1':'1',
+               '2':'2',
+               '3':'3'}
+
+strike_dict =  {'0':'0',
+               '1':'1',
+               '2':'2'}
+
+# count_dict = {'0_0':'Through 0-0',
+#                  '0_1':'Through 0-1',
+#                  '0_2':'Through 0-2',
+#                  '1_0':'Through 1-0',
+#                  '1_1':'Through 1-1',
+#                  '1_2':'Through 1-2',
+#                  '2_1':'Through 2-1',
+#                  '2_0':'Through 2-0',
+#                  '3_0':'Through 3-0',
+#                  '3_1':'Through 3-1',
+#                  '2_2':'Through 2-2',
+#                  '3_2':'Through 3-2'}
+
+# count_dict_fg = {'0_0':'',
+#                  '0_1':'61',
+#                  '0_2':'62',
+#                  '1_0':'63',
+#                  '1_1':'64',
+#                  '1_2':'65',
+#                  '2_1':'66',
+#                  '2_0':'67',
+#                  '3_0':'68',
+#                  '3_1':'69',
+#                  '2_2':'70',
+#                  '3_2':'71'}
 
-    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'),
-    )
+from urllib.request import Request, urlopen
+from shiny import App, reactive, ui, render
+from shiny.ui import h2, tags
+# importing OpenCV(cv2) module
+app_ui = ui.page_fluid(
+    ui.layout_sidebar(
+ 
+        ui.panel_sidebar(
+                ui.row(
+                ui.column(6,
+                    ui.input_select('player_id','Select Player',pitcher_dicts,selectize=True,multiple=False)),
+                ui.column(6,    ui.output_ui('test','Select Game'))),
+                
+                ui.row(
+                ui.column(4,
+                    ui.input_select('plot_id_1','Plot Left',function_dict,multiple=False,selected='velocity_kde')),
+                ui.column(4,
+                    ui.input_select('plot_id_2','Plot Middle',function_dict,multiple=False,selected='rolling_tj_stuff')),
+                ui.column(4,
+                    ui.input_select('plot_id_3','Plot Right',function_dict,multiple=False,selected='break_plot'))),
+
+                # ui.input_select('count_id','Count',count_dict,multiple=True,selectize=True,selected='0_0'),
+
+                ui.row(
+                ui.column(6,
+                        ui.input_select('ball_id','Balls',ball_dict,multiple=False,selected='0'),
+                                                ui.input_radio_buttons(
+                                                    "count_id_balls",
+                                                    "Count Filter Balls",
+                                                    {
+                                                        "exact": "Exact Balls",
+                                                        "greater": ">= Balls",
+                                                        "lesser": "<= Balls",
+                                                    },selected='greater')),
+                ui.column(6,                                    
+                        ui.input_select('strike_id','Strikes',strike_dict,multiple=False,selected='0'),
+                        ui.input_radio_buttons(
+                                                    "count_id_strikes",
+                                                    "Count Filter Strikes",
+                                                    {
+                                                        "exact": "Exact Strikes",
+                                                        "greater": ">= Strikes",
+                                                        "lesser": "<= Strikes",
+                                                    },selected='greater'))),
+                ui.row(
+                    ui.column(6,
+                        ui.input_select('split_id','Select Split',split_dict,multiple=False)),
+                    ui.column(6,
+                        ui.input_numeric('rolling_window','Rolling Window (for tjStuff+ Plot)',min=1,value=10))),
+
+
+                
+                ui.input_action_button("go", "Generate",class_="btn-primary"),
+                               
+                                       
+                                       width=4)
+                ,
+        ui.panel_main(     
+            ui.navset_tab(
+            # ui.nav("Raw Data",
+            #     ui.output_data_frame("raw_table")),                
+            ui.nav("Season Summary",
+                   ui.output_plot('plot',
+                                  width='2000px',
+                                  height='2000px')),
+            ui.nav("Game Summary",
+                   ui.output_plot('plot_game',
+                                  width='2000px',
+                                  height='2000px'))
+                ,id="my_tabs"))))
 
-    df_copy = df_copy.merge(df_copy_fb_sum,left_on='pitcher_id',right_index=True,how='left')
 
-    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']
 
-    # 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
 
 
-    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']
 
-    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_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_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_copy['x_diff'] = df_copy['x0'] - df_copy['px']
-    # df_copy['z_diff'] = df_copy['z0'] - df_copy['pz']
 
-    # 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
+#print(app_ui)
+def server(input, output, session):
 
-    df_copy = df_copy.dropna(subset=['pitch_type']).fillna(0)
-    return df_copy
+    @render.ui
+    def test():
 
+            # @reactive.Effect
+            if input.my_tabs() == 'Season Summary':   
 
-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(),
+                return 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")),     
-
-                ))))
+                                       max=df_2024.game_date.max()),        
+            # @reactive.Effect
+            if input.my_tabs() == 'Game Summary':
+                pitcher_id_select = int(input.player_id())
+                df_plot = df_2024_update[(df_2024_update['pitcher_id']==pitcher_id_select)]
+                
+
+                # ax0.text(x=0.5,y=0.30,s=f'2024 Spring Training',fontname='Calibri',ha='center',fontsize=30,va='top')
+                df_plot['game_opp'] = df_plot['game_date'].astype(str) + ' vs ' + df_plot['batter_team'].astype(str)
+                #print(df_plot['game_opp'])
+
+                date_dict = pd.concat([df_plot.drop_duplicates(subset=['pitcher_id','game_id','game_opp'])[['game_id','game_opp']]]).set_index('game_id').to_dict()
+                return ui.input_select("game_id", "Select Game",date_dict,selectize=True)
+            
+    @output
+    @render.plot
+    @reactive.event(input.go, ignore_none=False)
+    def plot():
+        #fig, ax = plt.subplots(3, 2, figsize=(9, 9))
+
+        font_properties = {'family': 'calibi', 'size': 12}
+        font_properties_titles = {'family': 'calibi', 'size': 20}
+        font_properties_axes = {'family': 'calibi', 'size': 16}
+                
+        if len((input.player_id()))<1:
+            fig, ax = plt.subplots(1, 1, figsize=(9, 9))
+            ax.text(x=0.5,y=0.5,s='Please Select\nA Player',fontsize=150,ha='center')
+            ax.grid('off')
+            return                
+        
+        pitcher_id_select = int(input.player_id())
+
+
+        df_plot = df_2024_update[(df_2024_update['pitcher_id']==pitcher_id_select)]
+
+        df_plot = df_plot[df_plot['batter_hand'].isin(split_dict_hand[input.split_id()])]
+
+        if input.count_id_balls()=='greater' and input.count_id_strikes()=='greater' and int(input.ball_id())==0 and int(input.strike_id())==0:
+            ball_title = ''
+            strike_title = ''
+        else: 
+            if input.count_id_balls()=='exact':
+                df_plot = df_plot[df_plot['balls']==int(input.ball_id())]
+                ball_title = str(f'{(input.ball_id())} Ball Count; ')                                                   
+            elif input.count_id_balls()=='greater':
+                df_plot = df_plot[df_plot['balls']>=int(input.ball_id())]
+                ball_title = str(f'At Least {(input.ball_id())} Ball Count; ')                         
+            elif input.count_id_balls()=='lesser':  
+                df_plot = df_plot[df_plot['balls']<=int(input.ball_id())]
+                ball_title = str(f'At Most {(input.ball_id())} Ball Count; ')                                        
+
+            if input.count_id_strikes()=='exact':
+                df_plot = df_plot[df_plot['strikes']==int(input.strike_id())]     
+                strike_title = str(f'{(input.strike_id())} Strike Count; ')                           
+            elif input.count_id_strikes()=='greater':
+                df_plot = df_plot[df_plot['strikes']>=int(input.strike_id())]     
+                strike_title = str(f'At Least {(input.strike_id())} Strike Count; ')            
+            elif input.count_id_strikes()=='lesser':
+                df_plot = df_plot[df_plot['strikes']<=int(input.strike_id())]  
+                strike_title = str(f'At Most {(input.strike_id())} Strike Count; ')                                        
+                                      
+
+
+        if input.split_id() == 'all':
+            split_title = ''
+
+        elif input.split_id() == 'left':
+            split_title = 'vs. LHH'
+            
+        elif input.split_id() == 'right':
+            split_title = 'vs. RHH'
+
+
+        if len(df_plot)<1:
+            fig, ax = plt.subplots(1, 1, figsize=(9, 9))
+            ax.text(x=0.5,y=0.5,s='Please Select\nOther Parameters',fontsize=150,ha='center')
+            ax.grid('off')
+            return
+
+        df_plot['pitch_type_count'] = df_plot.groupby(['pitcher_id'])['pitch_type'].cumcount()+1
+        df_plot['pitch_type_count_each'] = df_plot.groupby(['pitch_type'])['pitch_type'].cumcount()+1
+        #df_plot = df_plot.merge(df_2024_update[['tj_stuff_plus','play_id']],left_on=['play_id'],right_on=['play_id'],how='left')
+        df_plot = df_plot.sort_values(by=['pitch_description'])
+
+        grouped_ivb = psf.group_ivb_update(df=df_plot,agg_list=['pitcher_id','pitcher_name','pitcher_hand','pitch_type','pitch_description'])
+        grouped_ivb_all = psf.group_ivb_update(df=df_plot,agg_list=['pitcher_id','pitcher_name','pitcher_hand'])
+
+
+
+        from matplotlib.gridspec import GridSpec
+        plt.rcParams['font.family'] = 'Calibri'
+        df_plot['prop'] = df_plot.groupby("pitch_type")["is_pitch"].transform("sum")
+        label_labels = df_plot.sort_values(by=['prop','pitch_type'],ascending=[False,True]).pitch_description.unique()
+
+        #plt.rcParams["figure.figsize"] = [10,10]
+        fig = plt.figure(figsize=(20, 20))
+        plt.rcParams.update({'figure.autolayout': True})
+        fig.set_facecolor('white')
+        sns.set_theme(style="whitegrid", palette=colour_palette)
+        print('this is the one plot')
+        # gs = GridSpec(7, 2, width_ratios=[1,1], height_ratios=[1.5,1,1,1,1,1,2.5])
+        gs = GridSpec(5, 5,  height_ratios=[150,75,225,325,50],width_ratios=[1,100,100,100,1])
+        #### NO FG
+        ####gs = GridSpec(5, 5,  height_ratios=[225,0,225,325,50],width_ratios=[1,100,100,100,1])
+        #gs = GridSpec(4, 1, width_ratios=[1], height_ratios=[1,0.75,7-len(label_labels)/4,1+len(label_labels)/4])
+
+        gs.update(hspace=0.2, wspace=0.3)
+
+        # Add subplots to the grid
+        ax0 = fig.add_subplot(gs[0, :]) 
+        ax1_table = fig.add_subplot(gs[1, :])
+        ax2_left = fig.add_subplot(gs[2, 1]) 
+        ax2_middle = fig.add_subplot(gs[2, 2]) 
+        ax2_right = fig.add_subplot(gs[2, 3])
+        ax3 = fig.add_subplot(gs[-2, :])
+        #axfooter = fig.add_subplot(gs[-1, :])
+
+        ax1_table.axis('off')
+
+        sns.set_theme(style="whitegrid", palette=colour_palette)
+        fig.set_facecolor('white')
+
+        font_properties = {'family': 'calibi', 'size': 12}
+        font_properties_titles = {'family': 'calibi', 'size': 20}
+        font_properties_axes = {'family': 'calibi', 'size': 16}
+
+        ## FANGRAPHS TABLE ###
+        data_pull = psf.fangraphs_scrape(pitcher_id=pitcher_id_select,
+                            split=input.split_id(),
+                            start_date=input.date_range_id()[0],
+                            end_date=input.date_range_id()[1])
+
+
+        psf.fangraphs_table(data=data_pull,
+                            stats=['IP','WHIP','ERA','FIP','TBF','K%','BB%','K-BB%'],
+                            ax=ax1_table)
+
+        for x,y,z in zip([input.plot_id_1(),input.plot_id_2(),input.plot_id_3()],[ax2_left,ax2_middle,ax2_right],[1,2,3]):
+            if x == 'velocity_kde':
+                psf.velocity_kdes(df=df_plot,ax=y,gs=gs,gs_list=z,fig=fig)
+            if x == 'rolling_tj_stuff':
+                psf.tj_stuff_roling(df = df_plot,window = int(input.rolling_window()),ax=y)
+            if x == 'break_plot':
+                psf.break_plot(df=df_plot,ax=y) 
+            if x == 'location_lhb':
+                psf.location_plot(df=df_plot,ax=y,hand='L')
+            if x == 'location_rhb':
+                psf.location_plot(df=df_plot,ax=y,hand='R')
+
+        pitches_list = df_plot['pitch_description'].unique()
+        colour_pitches = [pitch_colours[x] for x in pitches_list]
+        
+    #     handles, labels = ax2_right.get_legend_handles_labels()
+
+    #   # Manually create handles and labels for each pitch-color pair
+        handles = [plt.scatter([], [], color=color, marker='o', s=100) for color in colour_pitches]
+        labels = pitches_list  
+        
+                
 
 
-from urllib.request import Request, urlopen
-from shiny import App, reactive, ui
-from shiny.ui import h2, tags
-# importing OpenCV(cv2) module
+        ### FANGRAPHS TABLE ###
+        psf.table_summary(df=df_plot.copy(),
+                        pitcher_id=pitcher_id_select,
+                        ax=ax3,
+                        df_group=grouped_ivb.copy(),
+                        df_group_all=grouped_ivb_all.copy(),
+                        statcast_pitch_summary=statcast_pitch_summary.copy())
 
 
+        # ############ FOOTER ################
+        # #fig.text(x=0.5,y=0.05,s='Note: Colour Coding Compares to League Average By Pitch',ha='center',fontname='Calibri',fontsize=10)
+        # axfooter.text(x=0.05,y=1,s='By: Thomas Nestico\n      @TJStats',fontname='Calibri',ha='left',fontsize=24,va='top')
+        # axfooter.text(x=1-0.05,y=1,s='Data: MLB, Fangraphs',ha='right',fontname='Calibri',fontsize=24,va='top')
 
 
-#print(app_ui)
-def server(input, output, session):
+        # axfooter.text(x=0.5,y=0.8,s='Colour Coding Compares to League Average By Pitch\ntjStuff+ calculates the Expected Run Value (xRV) of a pitch regardless of type\ntjStuff+ is normally distributed, where 100 is the mean and Standard Deviation is 10',
+        #             ha='center',va='center',fontname='Calibri',fontsize=16)
+        # axfooter.axis('off')
+        # #fig.tight_layout()
 
-    # @output
-    # @render.data_frame
-    # def raw_table():
+        
 
-    #     return render.DataGrid(
-    #         df_2024,
-    #         width='fit-content',
-    #         height=750,
-    #         filters=True,
-    #     )        
+        # Get value counts of the column and sort in descending order
+        sorted_value_counts = df_plot['pitch_description'].value_counts().sort_values(ascending=False)
 
-    @output
-    @render.data_frame
-    def table():
+        # Get the list of items ordered from most to least frequent
+        items_in_order = sorted_value_counts.index.tolist()
+        # Create a dictionary to map names to colors
+        name_to_color = dict(zip(labels, handles))
 
-        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,
-        )        
+        # Order the colors based on the correct order of names
+        ordered_colors = [name_to_color[name] for name in items_in_order]
 
-    @output
-    @render.data_frame
-    def table_daily():
 
-        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
+        ax3.legend(ordered_colors, items_in_order, bbox_to_anchor=(0.1, 0.81, 0.8, 0.2), ncol=5,
+                fancybox=True,loc='lower center',fontsize=20,framealpha=1.0, markerscale=2,prop={'family': 'calibi', 'size': 20})
 
-    @output
-    @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'])
 
-        
+        ################## Title ##########
+        title_spot = f'{df_plot.pitcher_name.values[0]}'
 
-        #####
-        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.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'])
 
-        
+        ax0.text(x=0.5,y=0.8,s=title_spot,fontname='Calibri',ha='center',fontsize=56,va='top')
+        ax0.text(x=0.5,y=0.5,s='Season Pitching Summary',fontname='Calibri',ha='center',fontsize=40,va='top',fontstyle='italic')
+
+
+        #ax0.text(x=0.5,y=0.25,s=f'2024 Spring Training',fontname='Calibri',ha='center',fontsize=30,va='top')
+        # ax0.text(x=0.5,y=0.25,s=f'{season_fg} MLB Season',fontname='Calibri',ha='center',fontsize=30,va='top')
+        # ax0.axis('off')
 
-        #####
-        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'),
+
+        ax0.text(x=0.5,y=0.25,s=f'{input.date_range_id()[0]} to {input.date_range_id()[1]}',fontname='Calibri',ha='center',fontsize=30,va='top',fontstyle='italic')
+        
+        ax0.text(x=0.5,y=0.05,s=f'{ball_title}{strike_title}{split_title}',fontname='Calibri',ha='center',fontsize=20,va='top')
+        ax0.axis('off')
+
+        from matplotlib.offsetbox import (OffsetImage, AnnotationBbox)
+        import urllib
+        import urllib.request
+        import urllib.error
+        from urllib.error import HTTPError
+
+        try: 
+            url = f'https://img.mlbstatic.com/mlb-photos/image/upload/d_people:generic:headshot:67:current.png/w_213,q_auto:best/v1/people/{pitcher_id_select}/headshot/67/current.png'
+            test_mage = plt.imread(url)
+        except urllib.error.HTTPError as err:
+            url = f'https://img.mlbstatic.com/mlb-photos/image/upload/d_people:generic:headshot:67:current.png/w_213,q_auto:best/v1/people/1/headshot/67/current.png'                
+        imagebox = OffsetImage(test_mage, zoom = 0.5)
+        ab = AnnotationBbox(imagebox, (0.125, 0.4), frameon = False)
+        ax0.add_artist(ab)
+
+        player_bio = requests.get(url=f"https://statsapi.mlb.com/api/v1/people?personIds={pitcher_id_select}&hydrate=currentTeam").json()
+
+
+
+
+        if 'currentTeam' in player_bio['people'][0]:
+            try:
+                url = team_logos[team_logos['id'] == team_logo_dict[player_bio['people'][0]['currentTeam']['id']]]['imageLink'].values[0]
+
+                im = plt.imread(url)
+                # response = requests.get(url)
+                # im = Image.open(BytesIO(response.content))
+                # im = plt.imread(team_logos[team_logos['id'] == player_bio['people'][0]['currentTeam']['parentOrgId']]['imageLink'].values[0])
+                # ax = fig.add_axes([0,0,1,0.85], anchor='C', zorder=1)
+                imagebox = OffsetImage(im, zoom = 0.4)
+                ab = AnnotationBbox(imagebox, (0.875, 0.40), frameon = False)
+                ax0.add_artist(ab)
+            except IndexError:
+                print()
             
-    #         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,
-    #     )                  
 
-    @output
-    @render.data_frame
-    def table_stuff():
-   
+        ############ FOOTER ################
+        #fig.text(x=0.5,y=0.05,s='Note: Colour Coding Compares to League Average By Pitch',ha='center',fontname='Calibri',fontsize=10)
+        axfooter = fig.add_subplot(gs[-1, :])
+        axfooter.text(x=0.05,y=1,s='By: Thomas Nestico\n      @TJStats',fontname='Calibri',ha='left',fontsize=24,va='top')
+        axfooter.text(x=1-0.05,y=1,s='Data: MLB, Fangraphs',ha='right',fontname='Calibri',fontsize=24,va='top')
 
-        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])])
 
-        features = ['start_speed','spin_rate','extension','ivb','hb','x0','z0','fb_max_velo_diff','fb_max_ivb_diff','fb_max_hb_diff']
+        axfooter.text(x=0.5,y=0.8,s='Colour Coding Compares to League Average By Pitch\ntjStuff+ calculates the Expected Run Value (xRV) of a pitch regardless of type\ntjStuff+ is normally distributed, where 100 is the mean and Standard Deviation is 10',
+                    ha='center',va='center',fontname='Calibri',fontsize=16)
+        axfooter.axis('off')
+        #fig.tight_layout()
 
-        targets = ['delta_run_exp_mean']
+        fig.subplots_adjust(left=0.03, right=0.97, top=0.97, bottom=0.03)
 
 
-        from scipy import stats
-        df_2024_update['y_pred'] = model.predict(df_2024_update[features])
+    @output
+    @render.plot
+    @reactive.event(input.go, ignore_none=False)
+    def plot_game():
+        #fig, ax = plt.subplots(3, 2, figsize=(9, 9))
+
+        font_properties = {'family': 'calibi', 'size': 12}
+        font_properties_titles = {'family': 'calibi', 'size': 20}
+        font_properties_axes = {'family': 'calibi', 'size': 16}
+                
+        if len((input.player_id()))<1:
+            fig, ax = plt.subplots(1, 1, figsize=(9, 9))
+            ax.text(x=0.5,y=0.5,s='Please Select\nA Player',fontsize=150,ha='center')
+            ax.grid('off')
+            return        
+        
+        pitcher_id_select = int(input.player_id())
 
 
-        y_pred_mean = -0.0023964706
-        y_pred_std =0.0057581966
-        # y_pred_mean = -0.0136602735
-        # y_pred_std = 0.006434487
 
-        ## 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'))
 
-        df_2024_stuff['run_exp_mean'] = y_pred_mean
-        df_2024_stuff['run_exp_std'] = y_pred_std
+        df_plot = df_2024_update[(df_2024_update['pitcher_id']==pitcher_id_select)&(df_2024_update['game_id']==int(input.game_id()))]
+        df_plot = df_plot[df_plot['batter_hand'].isin(split_dict_hand[input.split_id()])]
 
-        df_2024_stuff_50 = df_2024_stuff[df_2024_stuff.pitches >= 1]
+        if input.count_id_balls()=='greater' and input.count_id_strikes()=='greater' and int(input.ball_id())==0 and int(input.strike_id())==0:
+            ball_title = ''
+            strike_title = ''
+        else: 
+            if input.count_id_balls()=='exact':
+                df_plot = df_plot[df_plot['balls']==int(input.ball_id())]
+                ball_title = str(f'{(input.ball_id())} Ball Count; ')                                                   
+            elif input.count_id_balls()=='greater':
+                df_plot = df_plot[df_plot['balls']>=int(input.ball_id())]
+                ball_title = str(f'At Least {(input.ball_id())} Ball Count; ')                         
+            elif input.count_id_balls()=='lesser':  
+                df_plot = df_plot[df_plot['balls']<=int(input.ball_id())]
+                ball_title = str(f'At Most {(input.ball_id())} Ball Count; ')                                        
 
-        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)
+            if input.count_id_strikes()=='exact':
+                df_plot = df_plot[df_plot['strikes']==int(input.strike_id())]     
+                strike_title = str(f'{(input.strike_id())} Strike Count; ')                           
+            elif input.count_id_strikes()=='greater':
+                df_plot = df_plot[df_plot['strikes']>=int(input.strike_id())]     
+                strike_title = str(f'At Least {(input.strike_id())} Strike Count; ')            
+            elif input.count_id_strikes()=='lesser':
+                df_plot = df_plot[df_plot['strikes']<=int(input.strike_id())]  
+                strike_title = str(f'At Most {(input.strike_id())} Strike Count; ')                                        
+                                      
 
+                                    
 
-        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
+        if input.split_id() == 'all':
+            split_title = ''
 
-        df_2024_stuff_pitch_50 = df_2024_stuff_pitch[df_2024_stuff_pitch.pitches >= 1]
+        elif input.split_id() == 'left':
+            split_title = 'vs. LHH'
+            
+        elif input.split_id() == 'right':
+            split_title = 'vs. RHH'
+
+        if len(df_plot)<1:
+            fig, ax = plt.subplots(1, 1, figsize=(9, 9))
+            ax.text(x=0.5,y=0.5,s='Please Select\nOther Parameters',fontsize=150,ha='center')
+            ax.grid('off')
+            return
+
+
+        df_plot['pitch_type_count'] = df_plot.groupby(['pitcher_id'])['pitch_type'].cumcount()+1
+        df_plot['pitch_type_count_each'] = df_plot.groupby(['pitch_type'])['pitch_type'].cumcount()+1
+        #df_plot = df_plot.merge(df_2024_update[['tj_stuff_plus','play_id']],left_on=['play_id'],right_on=['play_id'],how='left')
+        df_plot = df_plot.sort_values(by=['pitch_description'])
+
+        # ax0.text(x=0.5,y=0.30,s=f'2024 Spring Training',fontname='Calibri',ha='center',fontsize=30,va='top')
+        df_plot['game_opp'] = df_plot['game_date'].astype(str) + ' vs ' + df_plot['batter_team'].astype(str)
+        #print(df_plot['game_opp'])
+
+        #date_dict = pd.concat([df_plot.drop_duplicates(subset=['pitcher_id','game_id','game_opp'])[['game_id','game_opp']]]).set_index('game_id').to_dict()
+
+        grouped_ivb = psf.group_ivb_update(df=df_plot,agg_list=['pitcher_id','pitcher_name','pitcher_hand','pitch_type','pitch_description'])
+        grouped_ivb_all = psf.group_ivb_update(df=df_plot,agg_list=['pitcher_id','pitcher_name','pitcher_hand'])
+
+
+
+        from matplotlib.gridspec import GridSpec
+        plt.rcParams['font.family'] = 'Calibri'
+        df_plot['prop'] = df_plot.groupby("pitch_type")["is_pitch"].transform("sum")
+        label_labels = df_plot.sort_values(by=['prop','pitch_type'],ascending=[False,True]).pitch_description.unique()
+
+        #plt.rcParams["figure.figsize"] = [10,10]
+        fig = plt.figure(figsize=(20, 20))
+        plt.rcParams.update({'figure.autolayout': True})
+        fig.set_facecolor('white')
+        sns.set_theme(style="whitegrid", palette=colour_palette)
+        print('this is the one plot')
+        # gs = GridSpec(7, 2, width_ratios=[1,1], height_ratios=[1.5,1,1,1,1,1,2.5])
+        gs = GridSpec(5, 5,  height_ratios=[150,75,225,325,50],width_ratios=[1,100,100,100,1])
+        #### NO FG
+        ####gs = GridSpec(5, 5,  height_ratios=[225,0,225,325,50],width_ratios=[1,100,100,100,1])
+        #gs = GridSpec(4, 1, width_ratios=[1], height_ratios=[1,0.75,7-len(label_labels)/4,1+len(label_labels)/4])
+
+        gs.update(hspace=0.2, wspace=0.3)
+
+        # Add subplots to the grid
+        ax0 = fig.add_subplot(gs[0, :]) 
+        ax1_table = fig.add_subplot(gs[1, :])
+        ax2_left = fig.add_subplot(gs[2, 1]) 
+        ax2_middle = fig.add_subplot(gs[2, 2]) 
+        ax2_right = fig.add_subplot(gs[2, 3])
+        ax3 = fig.add_subplot(gs[-2, :])
+        # axfooter = fig.add_subplot(gs[-1, :])
+
+        ax1_table.axis('off')
+
+        sns.set_theme(style="whitegrid", palette=colour_palette)
+        fig.set_facecolor('white')
+
+        font_properties = {'family': 'calibi', 'size': 12}
+        font_properties_titles = {'family': 'calibi', 'size': 20}
+        font_properties_axes = {'family': 'calibi', 'size': 16}
+
+        print(df_2024_update['game_date'].values[0])
+        ## FANGRAPHS TABLE ###
+        data_pull = psf.fangraphs_scrape(pitcher_id=pitcher_id_select,
+                            split=input.split_id(),
+                            start_date=df_plot['game_date'].values[0],
+                            end_date=df_plot['game_date'].values[0])
+
+
+        psf.fangraphs_table(data=data_pull,
+                            stats=['IP','WHIP','ERA','FIP','TBF','K%','BB%','K-BB%'],
+                            ax=ax1_table)
+
+        # psf.velocity_kdes(df=df_plot,
+        #                 ax=ax2_loc,
+        #                 gs=gs,
+        #                 fig=fig)
+
+        # # psf.tj_stuff_roling(df = df_plot,
+        # #                     window = 5,
+        # #                     ax=ax2_velo)
+        # psf.location_plot(df=df_plot,ax=ax2_velo,hand='L')
+
+        # psf.location_plot(df=df_plot,ax=ax2_loc,hand='R')
+        # # # ## Break Plot
+        # psf.break_plot(df=df_plot,ax=ax2) 
+        for x,y,z in zip([input.plot_id_1(),input.plot_id_2(),input.plot_id_3()],[ax2_left,ax2_middle,ax2_right],[1,2,3]):
+            if x == 'velocity_kde':
+                psf.velocity_kdes(df=df_plot,ax=y,gs=gs,gs_list=z,fig=fig)
+            if x == 'rolling_tj_stuff':
+                psf.tj_stuff_roling(df = df_plot,window = int(input.rolling_window()),ax=y)
+            if x == 'break_plot':
+                psf.break_plot(df=df_plot,ax=y) 
+            if x == 'location_lhb':
+                psf.location_plot(df=df_plot,ax=y,hand='L')
+            if x == 'location_rhb':
+                psf.location_plot(df=df_plot,ax=y,hand='R')
+
+        pitches_list = df_plot['pitch_description'].unique()
+        colour_pitches = [pitch_colours[x] for x in pitches_list]
+        
+    #     handles, labels = ax2_right.get_legend_handles_labels()
 
-        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)
+    #   # Manually create handles and labels for each pitch-color pair
+        handles = [plt.scatter([], [], color=color, marker='o', s=100) for color in colour_pitches]
+        labels = pitches_list  
 
-        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'])
 
-        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()
+        ### FANGRAPHS TABLE ###
+        psf.table_summary(df=df_plot.copy(),
+                        pitcher_id=pitcher_id_select,
+                        ax=ax3,
+                        df_group=grouped_ivb.copy(),
+                        df_group_all=grouped_ivb_all.copy(),
+                        statcast_pitch_summary=statcast_pitch_summary.copy())
 
-        return render.DataGrid(
-            df_2024_stuff_pitch_50_pivot,
-            width='fit-content',
-            height=750,
-            filters=True)          
-    
-    @output
-    @render.data_frame
-    def table_stuff_day():
 
 
-        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')
 
-        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']
+        # Get value counts of the column and sort in descending order
+        sorted_value_counts = df_plot['pitch_description'].value_counts().sort_values(ascending=False)
 
+        # Get the list of items ordered from most to least frequent
+        items_in_order = sorted_value_counts.index.tolist()
+        # Create a dictionary to map names to colors
+        name_to_color = dict(zip(labels, handles))
 
-        from scipy import stats
-        df_2024_update['y_pred'] = model.predict(df_2024_update[features])
+        # Order the colors based on the correct order of names
+        ordered_colors = [name_to_color[name] for name in items_in_order]
 
 
-        y_pred_mean = -0.0023964706
-        y_pred_std =0.0057581966
-        # y_pred_mean = -0.0136602735
-        # y_pred_std = 0.006434487
+        ax3.legend(ordered_colors, items_in_order, bbox_to_anchor=(0.1, 0.81, 0.8, 0.2), ncol=5,
+                fancybox=True,loc='lower center',fontsize=20,framealpha=1.0, markerscale=2,prop={'family': 'calibi', 'size': 20})
 
-        ## 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'))
 
-        df_2024_stuff_daily['run_exp_mean'] = y_pred_mean
-        df_2024_stuff_daily['run_exp_std'] = y_pred_std
+        ################## Title ##########
+        title_spot = f'{df_plot.pitcher_name.values[0]}'
 
-        df_2024_stuff_daily_50 = df_2024_stuff_daily[df_2024_stuff_daily.pitches >= 1]
 
-        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)
+        ax0.text(x=0.5,y=0.8,s=title_spot,fontname='Calibri',ha='center',fontsize=56,va='top')
+        ax0.text(x=0.5,y=0.5,s='Game Pitching Summary',fontname='Calibri',ha='center',fontsize=40,va='top',fontstyle='italic')
 
 
-        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'))
+        #ax0.text(x=0.5,y=0.25,s=f'2024 Spring Training',fontname='Calibri',ha='center',fontsize=30,va='top')
+        #ax0.text(x=0.5,y=0.25,s=f'{season_fg} MLB Season',fontname='Calibri',ha='center',fontsize=30,va='top')
+        #ax0.text(x=0.5,y=0.25,s=f'2024 Spring Training',fontname='Calibri',ha='center',fontsize=30,va='top')
+        # ax0.text(x=0.5,y=0.25,s=f'{season_fg} MLB Season',fontname='Calibri',ha='center',fontsize=30,va='top')
+
+        ax0.text(x=0.5,y=0.25,s= df_plot['game_opp'].values[0],fontname='Calibri',ha='center',fontstyle='italic',fontsize=30,va='top')
+        
+        ax0.text(x=0.5,y=0.05,s=f'{ball_title}{strike_title}{split_title}',fontname='Calibri',ha='center',fontsize=20,va='top')
+        ax0.axis('off')
 
-        df_2024_stuff_daily_pitch['run_exp_mean'] = y_pred_mean
-        df_2024_stuff_daily_pitch['run_exp_std'] = y_pred_std
 
-        df_2024_stuff_daily_pitch_50 = df_2024_stuff_daily_pitch[df_2024_stuff_daily_pitch.pitches >= 1]
+        from matplotlib.offsetbox import (OffsetImage, AnnotationBbox)
+        import urllib
+        import urllib.request
+        import urllib.error
+        from urllib.error import HTTPError
 
-        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)
+        try: 
+            url = f'https://img.mlbstatic.com/mlb-photos/image/upload/d_people:generic:headshot:67:current.png/w_213,q_auto:best/v1/people/{pitcher_id_select}/headshot/67/current.png'
+            test_mage = plt.imread(url)
+        except urllib.error.HTTPError as err:
+            url = f'https://img.mlbstatic.com/mlb-photos/image/upload/d_people:generic:headshot:67:current.png/w_213,q_auto:best/v1/people/1/headshot/67/current.png'                
+        imagebox = OffsetImage(test_mage, zoom = 0.5)
+        ab = AnnotationBbox(imagebox, (0.125, 0.4), frameon = False)
+        ax0.add_artist(ab)
 
-        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()
+        player_bio = requests.get(url=f"https://statsapi.mlb.com/api/v1/people?personIds={pitcher_id_select}&hydrate=currentTeam").json()
 
-        return render.DataGrid(
-            df_2024_stuff_daily_pitch_50_pivot,
-            width='fit-content',
-            height=750,
-            filters=True)          
 
 
 
+        if 'currentTeam' in player_bio['people'][0]:
+            try:
+                url = team_logos[team_logos['id'] == team_logo_dict[player_bio['people'][0]['currentTeam']['id']]]['imageLink'].values[0]
 
+                im = plt.imread(url)
+                # response = requests.get(url)
+                # im = Image.open(BytesIO(response.content))
+                # im = plt.imread(team_logos[team_logos['id'] == player_bio['people'][0]['currentTeam']['parentOrgId']]['imageLink'].values[0])
+                # ax = fig.add_axes([0,0,1,0.85], anchor='C', zorder=1)
+                imagebox = OffsetImage(im, zoom = 0.4)
+                ab = AnnotationBbox(imagebox, (0.875, 0.40), frameon = False)
+                ax0.add_artist(ab)
+            except IndexError:
+                print()
+            
+        ############ FOOTER ################
+        #fig.text(x=0.5,y=0.05,s='Note: Colour Coding Compares to League Average By Pitch',ha='center',fontname='Calibri',fontsize=10)
+        axfooter = fig.add_subplot(gs[-1, :])
+        axfooter.text(x=0.05,y=1,s='By: Thomas Nestico\n      @TJStats',fontname='Calibri',ha='left',fontsize=24,va='top')
+        axfooter.text(x=1-0.05,y=1,s='Data: MLB, Fangraphs',ha='right',fontname='Calibri',fontsize=24,va='top')
 
 
+        axfooter.text(x=0.5,y=0.8,s='Colour Coding Compares to League Average By Pitch\ntjStuff+ calculates the Expected Run Value (xRV) of a pitch regardless of type\ntjStuff+ is normally distributed, where 100 is the mean and Standard Deviation is 10',
+                    ha='center',va='center',fontname='Calibri',fontsize=16)
+        axfooter.axis('off')
+        #fig.tight_layout()
 
 
+        fig.subplots_adjust(left=0.03, right=0.97, top=0.97, bottom=0.03)
 
 app = App(app_ui, server)

joblib_model/barrel_model.joblib

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

joblib_model/in_zone.joblib

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

joblib_model/model_attack_zone.joblib

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

joblib_model/no_swing.joblib

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

joblib_model/swing.joblib

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

joblib_model/tjloc_model_20240311.joblib

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

joblib_model/tjstuff_model_20240123.joblib

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

joblib_model/tjstuff_model_20240317.joblib

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

joblib_model/tjstuff_model_20240318.joblib

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

joblib_model/xwoba_model.joblib

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

pitch_summary_functions.py

@@ -0,0 +1,1005 @@
+
+import pandas as pd
+import numpy as np
+import json
+from  matplotlib.ticker import FuncFormatter
+from matplotlib.ticker import MaxNLocator
+import math
+from matplotlib.patches import Ellipse
+import matplotlib.transforms as transforms
+import matplotlib.colors
+import matplotlib.colors as mcolors
+import seaborn as sns
+import matplotlib.pyplot as plt
+import requests
+
+font_properties = {'family': 'calibi', 'size': 12}
+font_properties_titles = {'family': 'calibi', 'size': 20}
+font_properties_axes = {'family': 'calibi', 'size': 16}
+     
+
+colour_palette = ['#FFB000','#648FFF','#785EF0',
+                  '#DC267F','#FE6100','#3D1EB2','#894D80','#16AA02','#B5592B','#A3C1ED']
+season_start = '2024-03-20'
+season_end = '2024-09-29'
+season_fg=2024 
+chad_fg = requests.get(f'https://www.fangraphs.com/api/leaders/major-league/data?age=&pos=all&stats=pit&lg=all&qual=0&season={season_fg}&season={season_fg}&month=1000&season1={season_fg}&ind=0&pageitems=2000000000&pagenum=1&ind=0&rost=0&players=&type=36&postseason=&sortdir=default&sortstat=sp_pitching').json()
+cmap_sum = matplotlib.colors.LinearSegmentedColormap.from_list("", ['#648FFF','#FFFFFF','#FFB000',])
+
+
+chadwick_df_small = pd.DataFrame(data={
+'key_mlbam':[x['xMLBAMID'] for x in chad_fg['data']],
+'key_fangraphs':[x['playerid'] for x in chad_fg['data']],
+'Name':[x['PlayerName'] for x in chad_fg['data']],
+})    
+
+pitcher_dicts = chadwick_df_small.set_index('key_mlbam')['Name'].sort_values().to_dict()
+mlb_fg_dicts = chadwick_df_small.set_index('key_mlbam')['key_fangraphs'].sort_values().to_dict()
+        
+        
+### DF UPDATE CODE ###
+def df_update_code(df):
+        print('Starting')
+        #df = pd.read_csv('2024_spring_data.csv',index_col=[0])
+        print('Starting')
+
+
+        df['vy_f'] = -(df['vy0']**2 - (2 * df['ay'] * (df['y0'] - 17/12)))**0.5
+        df['t'] = (df['vy_f'] - df['vy0']) / df['ay']
+        df['vz_f'] = (df['vz0']) + (df['az'] * df['t'])
+        df['vaa'] = -np.arctan(df['vz_f'] / df['vy_f']) * (180 / np.pi)
+
+        #df['vy_f'] = -(df['vy0']**2 - (2 * df['ay'] * (df['y0'] - 17/12)))**0.5
+        #df['t'] = (df['vy_f'] - df['vy0']) / df['ay']
+        df['vx_f'] = (df['vx0']) + (df['ax'] * df['t'])
+        df['haa'] = -np.arctan(df['vx_f'] / df['vy_f']) * (180 / np.pi)
+
+
+
+        end_codes = ['strikeout', 'field_out', 'single', 'walk', 'hit_by_pitch',
+            'double', 'sac_fly', 'force_out', 'home_run',
+            'grounded_into_double_play', 'fielders_choice', 'field_error',
+            'triple', 'sac_bunt', 'double_play', 'intent_walk',
+            'fielders_choice_out', 'strikeout_double_play',
+            'sac_fly_double_play', 'catcher_interf', 'other_out']
+
+
+
+        df['pa'] = df.event_type.isin(end_codes)
+        #df['pa'] = 1
+        df['k'] = df.event_type.isin(list(filter(None, [x if 'strikeout' in x else '' for x in df.event_type.fillna('None').unique()])))
+        df['bb'] = df.event_type.isin(list(filter(None, [x if 'walk' in x else '' for x in df.event_type.fillna('None').unique()])))
+        df['k_minus_bb'] = df['k'].astype(np.float32)-df['bb'].astype(np.float32)
+
+        df = df.drop_duplicates(subset=['play_id'])
+        df = df.dropna(subset=['start_speed'])
+
+
+
+        swing_codes = ['Swinging Strike', 'In play, no out', 
+                'Foul', 'In play, out(s)', 
+            'In play, run(s)', 'Swinging Strike (Blocked)',
+            'Foul Bunt','Foul Tip', 'Missed Bunt','Foul Pitchout','Swinging Pitchout']
+
+        swings_in = ['Swinging Strike', 'In play, no out', 
+                'Foul', 'In play, out(s)', 
+            'In play, run(s)', 'Swinging Strike (Blocked)',
+            'Foul Bunt','Foul Tip', 'Missed Bunt','Foul Pitchout','Swinging Pitchout']       
+
+        swing_strike_codes = ['Swinging Strike',
+        'Swinging Strike (Blocked)','Missed Bunt','Foul Tip','Swinging Pitchout']
+
+
+        contact_codes = ['In play, no out', 
+                'Foul', 'In play, out(s)', 
+            'In play, run(s)', 
+            'Foul Bunt']
+
+        codes_in = ['In play, out(s)',
+        'Swinging Strike',
+        'Ball',
+        'Foul',
+        'In play, no out',
+        'Called Strike',
+        'Foul Tip',
+        'In play, run(s)',
+        'Hit By Pitch',
+        'Ball In Dirt',
+        'Pitchout',
+        'Swinging Strike (Blocked)',
+        'Foul Bunt',
+        'Missed Bunt',
+        'Foul Pitchout',
+        'Intent Ball',
+        'Swinging Pitchout']
+
+        df['in_zone'] = df['zone'] < 10
+
+
+        df = df.drop_duplicates(subset=['play_id'])
+
+
+
+        df_codes = df[df.play_description.isin(codes_in)].dropna(subset=['in_zone'])
+
+        df_codes['bip'] = ~df_codes.launch_speed.isna()
+        conditions = [
+            (df_codes['launch_speed'].isna()),
+            (df_codes['launch_speed']*1.5 - df_codes['launch_angle'] >= 117 ) & (df_codes['launch_speed'] + df_codes['launch_angle'] >= 124) & (df_codes['launch_speed'] > 98) & (df_codes['launch_angle'] >= 8) & (df_codes['launch_angle'] <= 50)
+        ]
+
+        choices = [False,True]
+        df_codes['barrel'] = np.select(conditions, choices, default=np.nan)
+
+        conditions_ss = [
+            (df_codes['launch_angle'].isna()),
+            (df_codes['launch_angle'] >= 8 ) * (df_codes['launch_angle'] <= 32 ) 
+        ]
+
+        choices_ss = [False,True]
+        df_codes['sweet_spot'] = np.select(conditions_ss, choices_ss, default=np.nan)
+        conditions_hh = [
+            (df_codes['launch_speed'].isna()),
+            (df_codes['launch_speed'] >= 94.5 ) 
+        ]
+
+        choices_hh = [False,True]
+        df_codes['hard_hit'] = np.select(conditions_hh, choices_hh, default=np.nan)
+
+
+        conditions_tb = [
+            (df_codes['event_type']=='single'),
+            (df_codes['event_type']=='double'),
+            (df_codes['event_type']=='triple'),
+            (df_codes['event_type']=='home_run'),
+        ]
+
+        choices_tb = [1,2,3,4]
+
+        df_codes['tb'] = np.select(conditions_tb, choices_tb, default=np.nan)
+
+        conditions_woba = [
+            (df_codes['event_type']=='walk'),
+            (df_codes['event_type']=='hit_by_pitch'),    
+            (df_codes['event_type']=='single'),
+            (df_codes['event_type']=='double'),
+            (df_codes['event_type']=='triple'),
+            (df_codes['event_type']=='home_run'),
+        ]
+
+        choices_woba = [0.705,
+                        0.688,
+                        0.897,
+                        1.233,
+                        1.612,
+                        2.013]
+
+        df_codes['woba'] = np.select(conditions_woba, choices_woba, default=np.nan)
+
+
+        woba_codes = ['strikeout', 'field_out', 'single', 'walk', 'hit_by_pitch',
+            'double', 'sac_fly', 'force_out', 'home_run',
+            'grounded_into_double_play', 'fielders_choice', 'field_error',
+            'triple', 'sac_bunt', 'double_play',
+            'fielders_choice_out', 'strikeout_double_play',
+            'sac_fly_double_play', 'other_out']
+
+
+
+
+
+        conditions_woba_code = [
+            (df_codes['event_type'].isin(woba_codes))
+        ]
+
+        choices_woba_code = [1]
+
+        df_codes['woba_codes'] = np.select(conditions_woba_code, choices_woba_code, default=np.nan)
+
+
+        #df_codes['barrel']  = (df_codes.launch_speed >= 98) & (df_codes.launch_angle >= (26 - (-98 + df_codes.launch_speed))) & (df_codes.launch_angle <= 30 + (-98 + df_codes.launch_speed)) & (df_codes.launch_angle >= 8) & (df_codes.launch_angle <= 50)
+
+
+
+        #df_codes['barrel']  = (df_codes.launch_speed >= 98) & (df_codes.launch_angle >= (26 - (-98 + df_codes.launch_speed))) & (df_codes.launch_angle <= 30 + (-98 + df_codes.launch_speed)) & (df_codes.launch_angle >= 8) & (df_codes.launch_angle <= 50)
+        df_codes['pitches'] = 1
+        df_codes['whiffs'] = [1 if ((x == 'S')|(x == 'W')|(x =='T')) else 0 for x in df_codes.play_code]
+        df_codes['csw'] = [1 if ((x == 'S')|(x == 'W')|(x =='T')|(x == 'C')) else 0 for x in df_codes.play_code]
+        df_codes['swings'] = [1 if x in swings_in else 0 for x in df_codes.play_description]
+
+        df_codes['out_zone'] = df_codes.in_zone == False
+        df_codes['zone_swing'] = (df_codes.in_zone == True)&(df_codes.swings == 1)
+        df_codes['zone_contact'] = (df_codes.in_zone == True)&(df_codes.swings == 1)&(df_codes.whiffs == 0)
+        df_codes['ozone_swing'] = (df_codes.in_zone==False)&(df_codes.swings == 1)
+        df_codes['ozone_contact'] = (df_codes.in_zone==False)&(df_codes.swings == 1)&(df_codes.whiffs == 0)
+
+        return df_codes
+
+### GET COLOURS##
+def get_color(value,normalize,cmap_sum):
+    color = cmap_sum(normalize(value))
+    return mcolors.to_hex(color)
+
+### PERCENTILE ###
+def percentile(n):
+    def percentile_(x):
+        return x.quantile(n)
+    percentile_.__name__ = 'percentile_{:02.0f}'.format(n*100)
+    return percentile_
+
+### TJ STUFF+ DF CLEAN ###
+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", "CS", "SC", "FA"])].reset_index(drop=True)
+    #df_copy = df_copy[~df_copy.pitch_type.isin(["EP", "PO", "CS", "SC", "FA"])].reset_index(drop=True)
+
+    df_copy['pitch_type'] = df_copy['pitch_type'].replace({'FT':'SI',
+                                                           #'KC':'CU',
+                                                           'SV':'SL',
+                                                           'FO':'FS'})
+
+    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'),
+    )
+
+    df_copy = df_copy.merge(df_copy_fb_sum,left_on='pitcher_id',right_index=True,how='left')
+
+    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'] = -abs(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']
+
+    # 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
+
+
+    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']
+
+    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_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_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_copy['x_diff'] = df_copy['x0'] - df_copy['px']
+    # df_copy['z_diff'] = df_copy['z0'] - df_copy['pz']
+
+    # 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
+
+    df_copy = df_copy.dropna(subset=['pitch_type']).fillna(0)
+    return df_copy
+
+### PITCH COLOURS ###
+pitch_colours = {
+        'Four-Seam Fastball':'#FF007D',#BC136F
+        'Sinker':'#98165D',#DC267F
+        'Cutter':'#BE5FA0',
+
+        'Changeup':'#F79E70',#F75233
+        'Splitter':'#FE6100',#F75233
+        'Screwball':'#F08223',
+        'Forkball':'#FFB000',
+        
+        'Slider':'#67E18D',#1BB999#785EF0
+        'Sweeper':'#1BB999',#37CD85#904039
+        'Slurve':'#376748',#785EF0#549C07#BEABD8
+
+        'Knuckle Curve':'#311D8B',  
+        'Curveball':'#3025CE',
+        'Slow Curve':'#274BFC',
+        'Eephus':'#648FFF',
+
+        'Knuckleball':'#867A08',
+
+        'Pitch Out':'#472C30',
+        'Other':'#9C8975',
+        }
+
+### PITCH ELLIPSE ###
+def confidence_ellipse(x, y, ax, n_std=3.0, facecolor='none', **kwargs):
+    """
+    Create a plot of the covariance confidence ellipse of *x* and *y*.
+
+    Parameters
+    ----------
+    x, y : array-like, shape (n, )
+        Input data.
+
+    ax : matplotlib.axes.Axes
+        The axes object to draw the ellipse into.
+
+    n_std : float
+        The number of standard deviations to determine the ellipse's radiuses.
+
+    **kwargs
+        Forwarded to `~matplotlib.patches.Ellipse`
+
+    Returns
+    -------
+    matplotlib.patches.Ellipse
+    """
+    
+    if x.size != y.size:
+        raise ValueError("x and y must be the same size")
+    try:
+        cov = np.cov(x, y)
+        pearson = cov[0, 1]/np.sqrt(cov[0, 0] * cov[1, 1])
+        # Using a special case to obtain the eigenvalues of this
+        # two-dimensional dataset.
+        ell_radius_x = np.sqrt(1 + pearson)
+        ell_radius_y = np.sqrt(1 - pearson)
+        ellipse = Ellipse((0, 0), width=ell_radius_x * 2, height=ell_radius_y * 2,
+                        facecolor=facecolor,linewidth=2,linestyle='--', **kwargs)
+        
+
+        # Calculating the standard deviation of x from
+        # the squareroot of the variance and multiplying
+        # with the given number of standard deviations.
+        scale_x = np.sqrt(cov[0, 0]) * n_std
+        mean_x = np.mean(x)
+        
+
+        # calculating the standard deviation of y ...
+        scale_y = np.sqrt(cov[1, 1]) * n_std
+        mean_y = np.mean(y)
+        
+
+        transf = transforms.Affine2D() \
+            .rotate_deg(45) \
+            .scale(scale_x, scale_y) \
+            .translate(mean_x, mean_y)
+        
+        
+
+        ellipse.set_transform(transf + ax.transData)
+    except ValueError:
+         return    
+        
+    return ax.add_patch(ellipse)
+
+# DEFINE STRIKE ZONE
+strike_zone = pd.DataFrame({
+'PlateLocSide': [-0.9, -0.9, 0.9, 0.9, -0.9],
+'PlateLocHeight': [1.5, 3.5, 3.5, 1.5, 1.5]
+})
+
+### STRIKE ZONE ###
+def draw_line(axis,alpha_spot=1,catcher_p = True):
+
+    axis.plot(strike_zone['PlateLocSide'], strike_zone['PlateLocHeight'], color='black', linewidth=1.3,zorder=3,alpha=alpha_spot,)
+
+    # ax.plot([-0.2833333, -0.2833333], [1.6, 3.5], color='black', linestyle='dashed',alpha=alpha_spot,zorder=3)
+    # ax.plot([0.2833333, 0.2833333], [1.6, 3.5], color='black', linestyle='dashed',alpha=alpha_spot,zorder=3)
+    # ax.plot([-0.85, 0.85], [2.2, 2.2], color='black', linestyle='dashed',alpha=alpha_spot,zorder=3)
+    # ax.plot([-0.85, 0.85], [2.9, 2.9], color='black', linestyle='dashed',alpha=alpha_spot,zorder=3)
+    if catcher_p:
+    # Add dashed line
+    # Add home plate
+        axis.plot([-0.708, 0.708], [0.15, 0.15], color='black', linewidth=1,alpha=alpha_spot,zorder=1)
+        axis.plot([-0.708, -0.708], [0.15, 0.3], color='black', linewidth=1,alpha=alpha_spot,zorder=1)
+        axis.plot([-0.708, 0], [0.3, 0.5], color='black', linewidth=1,alpha=alpha_spot,zorder=1)
+        axis.plot([0, 0.708], [0.5, 0.3], color='black', linewidth=1,alpha=alpha_spot,zorder=1)
+        axis.plot([0.708, 0.708], [0.3, 0.15], color='black', linewidth=1,alpha=alpha_spot,zorder=1)
+    else:
+        axis.plot([-0.708, 0.708], [0.4, 0.4], color='black', linewidth=1,alpha=alpha_spot,zorder=1)
+        axis.plot([-0.708, -0.9], [0.4, -0.1], color='black', linewidth=1,alpha=alpha_spot,zorder=1)
+        axis.plot([-0.9, 0], [-0.1, -0.35], color='black', linewidth=1,alpha=alpha_spot,zorder=1)
+        axis.plot([0, 0.9], [-.35, -0.1], color='black', linewidth=1,alpha=alpha_spot,zorder=1)
+        axis.plot([0.9, 0.708], [-0.1,0.4], color='black', linewidth=1,alpha=alpha_spot,zorder=1)
+
+
+
+### FANGRAPHS STATS DICT ###
+fangraphs_stats_dict = {'IP':{'table_header':'$\\bf{IP}$','format':'.1f',} ,
+ 'TBF':{'table_header':'$\\bf{PA}$','format':'.0f',} ,
+ 'AVG':{'table_header':'$\\bf{AVG}$','format':'.3f',} ,
+ 'K/9':{'table_header':'$\\bf{K\/9}$','format':'.2f',} ,
+ 'BB/9':{'table_header':'$\\bf{BB\/9}$','format':'.2f',} ,
+ 'K/BB':{'table_header':'$\\bf{K\/BB}$','format':'.2f',} ,
+ 'HR/9':{'table_header':'$\\bf{HR\/9}$','format':'.2f',} ,
+ 'K%':{'table_header':'$\\bf{K\%}$','format':'.1%',} ,
+ 'BB%':{'table_header':'$\\bf{BB\%}$','format':'.1%',} ,
+ 'K-BB%':{'table_header':'$\\bf{K-BB\%}$','format':'.1%',} ,
+ 'WHIP':{'table_header':'$\\bf{WHIP}$','format':'.2f',} ,
+ 'BABIP':{'table_header':'$\\bf{BABIP}$','format':'.3f',} ,
+ 'LOB%':{'table_header':'$\\bf{LOB\%}$','format':'.1%',} ,
+ 'xFIP':{'table_header':'$\\bf{xFIP}$','format':'.2f',} ,
+ 'FIP':{'table_header':'$\\bf{FIP}$','format':'.2f',} ,
+ 'H':{'table_header':'$\\bf{H}$','format':'.0f',} ,
+ '2B':{'table_header':'$\\bf{2B}$','format':'.0f',} ,
+ '3B':{'table_header':'$\\bf{3B}$','format':'.0f',} ,
+ 'R':{'table_header':'$\\bf{R}$','format':'.0f',} ,
+ 'ER':{'table_header':'$\\bf{ER}$','format':'.0f',} ,
+ 'HR':{'table_header':'$\\bf{HR}$','format':'.0f',} ,
+ 'BB':{'table_header':'$\\bf{BB}$','format':'.0f',} ,
+ 'IBB':{'table_header':'$\\bf{IBB}$','format':'.0f',} ,
+ 'HBP':{'table_header':'$\\bf{HBP}$','format':'.0f',} ,
+ 'SO':{'table_header':'$\\bf{SO}$','format':'.0f',} ,
+ 'OBP':{'table_header':'$\\bf{OBP}$','format':'.0f',} ,
+ 'SLG':{'table_header':'$\\bf{SLG}$','format':'.0f',} ,
+ 'ERA':{'table_header':'$\\bf{ERA}$','format':'.2f',} ,
+ 'wOBA':{'table_header':'$\\bf{wOBA}$','format':'.3f',} ,
+ 'G':{'table_header':'$\\bf{G}$','format':'.0f',} }
+
+
+    ## Fangraphs Table
+
+### FANGRAPHS SPLITS SCRAPE ###
+split_dict = {'all':[],
+                'left':['5'],
+                'right':['6']
+                }
+
+def fangraphs_scrape(pitcher_id=808967,
+                    split='all',
+                    start_date='2024-03-20',
+                    end_date='2024-09-29'):
+
+
+        url = "https://www.fangraphs.com/api/leaders/splits/splits-leaders"
+
+        payload = {
+            "strPlayerId": str(mlb_fg_dicts[pitcher_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')),
+            "strSplitTeams": False,
+            "dctFilters": [],
+            "strStatType": "player",
+            "strAutoPt": False,
+            "arrPlayerId": [],
+            "strSplitArrPitch": [],
+            "arrWxTemperature": None,
+            "arrWxPressure": None,
+            "arrWxAirDensity": None,
+            "arrWxElevation": None,
+            "arrWxWindSpeed": None
+        }
+        json_payload = json.dumps(payload)
+        headers = {'Content-Type': 'application/json'}
+        response = requests.post(url, data=json_payload, headers=headers)
+        data_pull = response.json()['data'][0]
+
+        payload_advanced = {
+            "strPlayerId": str(mlb_fg_dicts[pitcher_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
+        }
+
+        json_payload_advanced = json.dumps(payload_advanced)
+        headers = {'Content-Type': 'application/json'}
+        response_advanced = requests.post(url, data=json_payload_advanced, headers=headers)
+        data_pull_advanced = response_advanced.json()['data'][0]
+
+        data_pull.update(data_pull_advanced)
+            
+        return data_pull
+
+
+### FANGRAPHS TABLE PLOT ###
+def fangraphs_table(data,
+                    stats,
+                    ax):
+        
+        
+        fg_values = [data[x] if x in data else '---' for x in stats]
+        df_fg = pd.DataFrame(data=dict(zip(stats,fg_values)),index=[0])
+
+        df_fg.loc[0] = [format(df_fg[x][0],fangraphs_stats_dict[x]['format']) if df_fg[x][0] != '---' else '---' for x in df_fg]
+        table_fg = ax.table(cellText=df_fg.values, colLabels=df_fg.columns, cellLoc='center',
+                        bbox=[0.04, 0.2, 0.92, 0.8])
+        
+        min_font_size = 20
+        table_fg.set_fontsize(min_font_size)
+
+
+        new_column_names = [fangraphs_stats_dict[x]['table_header'] if x in data else '---' for x in stats]
+        # #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')
+
+
+        return table_fg
+
+### VELOCITY KDES ###
+def velocity_kdes(df,
+                  ax,
+                  gs,
+                  gs_list,
+                  fig):
+
+        sorted_value_counts = df['pitch_type'].value_counts().sort_values(ascending=False)
+
+        # Get the list of items ordered from most to least frequent
+        items_in_order = sorted_value_counts.index.tolist()
+    
+        # Create the inner subplot inside the outer subplot
+        import matplotlib.gridspec as gridspec
+        ax.axis ('off')
+        #ax.set_ylabel('Pitch Velocity Distribution', fontdict=font_properties_axes)
+        ax.set_title('Pitch Velocity Distribution', fontdict={'family': 'calibi', 'size': 20})
+
+        inner_grid_1 = gridspec.GridSpecFromSubplotSpec(len(items_in_order),1, subplot_spec=gs[2,gs_list])
+        ax_top = []
+        for inner in inner_grid_1:
+            ax_top.append(fig.add_subplot(inner))
+
+
+        ax_number = 0
+
+        for i in items_in_order[0:]:
+            if np.unique(df[df['pitch_type']==i]['start_speed']).size == 1:  # Check if all values are the same
+                print('just')
+                ax_top[ax_number].plot([np.unique(df[df['pitch_type']==i]['start_speed']),np.unique(df[df['pitch_type']==i]['start_speed'])],[0,1], linewidth=4,
+                                color=pitch_colours[df[df['pitch_type']==i]['pitch_description'].values[0]],zorder=20)
+                #    ax_top[ax_number].plot(np.unique(df_melt[df_melt['Player']==i]['value']), [0.5]*len(np.unique(df_melt[df_melt['Player']==i]['value'])), linewidth=4)
+            else:
+                sns.kdeplot(df[df['pitch_type']==i]['start_speed'],ax=ax_top[ax_number],fill=True,
+                            clip=(df[df['pitch_type']==i]['start_speed'].min(),df[df['pitch_type']==i]['start_speed'].max()),
+                            color=pitch_colours[df[df['pitch_type']==i]['pitch_description'].values[0]])
+            ax_top[ax_number].set_xlim(math.floor(df['start_speed'].min()/5)*5,math.ceil(df['start_speed'].max()/5)*5)
+            ax_top[ax_number].set_xlabel('')
+            ax_top[ax_number].set_ylabel('')
+            if ax_number < len(items_in_order)-1:
+                ax_top[ax_number].spines['top'].set_visible(False)
+                ax_top[ax_number].spines['right'].set_visible(False)
+                ax_top[ax_number].spines['left'].set_visible(False)
+                ax_top[ax_number].tick_params(axis='x', colors='none')
+
+
+            ax_top[ax_number].set_xticks(range(math.floor(df['start_speed'].min()/5)*5,math.ceil(df['start_speed'].max()/5)*5,5))
+            ax_top[ax_number].set_yticks([])
+            ax_top[ax_number].grid(axis='x', linestyle='--')
+            ax_top[ax_number].text(-0.01, 0.5, i, transform=ax_top[ax_number].transAxes,
+                        fontsize=14, va='center', ha='right')
+            ax_number =   ax_number + 1
+        ax_top[-1].spines['top'].set_visible(False)
+        ax_top[-1].spines['right'].set_visible(False)
+        ax_top[-1].spines['left'].set_visible(False)
+
+
+        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,
+                    window,
+                    ax):
+        ## Velocity Plot
+        sorted_value_counts = df['pitch_type'].value_counts().sort_values(ascending=False)
+
+        # Get the list of items ordered from most to least frequent
+        items_in_order = sorted_value_counts.index.tolist()
+        
+
+        for i in items_in_order:
+            if max(df[df['pitch_type']==i]['pitch_type_count_each']) >= window:
+                sns.lineplot(x=range(1,max(df[df['pitch_type']==i]['pitch_type_count_each'])+1),
+                        y=df[df['pitch_type']==i]['tj_stuff_plus'].rolling(window).sum()/window,
+                    color=pitch_colours[df[df['pitch_type']==i]['pitch_description'].values[0]],
+                    ax=ax,linewidth=3)
+
+        # Adjust x-axis limits to start from 1
+        ax.set_xlim(window,max(df['pitch_type_count_each']))
+        ax.set_ylim(70,130)
+        #ax.get_legend().remove()
+        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.axis('square')
+        # ax.set_xlim(left=1)
+        ax.xaxis.set_major_locator(MaxNLocator(integer=True))
+
+### BREAK PLOT ###
+def break_plot(df,
+               ax): 
+
+        label_labels = df.sort_values(by=['prop','pitch_type'],ascending=[False,True]).pitch_description.unique()   
+        j = 0
+        for label in label_labels:
+                subset = df[df['pitch_description'] == label]
+                print(label)
+                if len(subset) > 4:
+                    if df['pitcher_hand'].values[0] == 'R':
+                        subset['hb'] = subset['hb']*1
+                    if df['pitcher_hand'].values[0] == 'L':
+                        subset['hb'] = subset['hb']*1
+                    subset['ivb'] = subset['ivb']*1
+                    
+                    try:
+                        confidence_ellipse(subset['hb'], subset['ivb'], ax=ax,edgecolor =  pitch_colours[label],n_std=2,facecolor=  pitch_colours[label],alpha=0.2)
+                    except ValueError:
+                        return
+                    j=j+1
+                else:
+                    j=j+1  
+                
+        if df['pitcher_hand'].values[0] == 'R':
+            sns.scatterplot(ax=ax,x=df.hb*1,y=df.ivb*1,hue=df.pitch_description,palette=pitch_colours,ec='black',alpha=1,zorder=2)
+        if df['pitcher_hand'].values[0] == 'L':
+            sns.scatterplot(ax=ax,x=df.hb*1,y=df.ivb*1,hue=df.pitch_description,palette=pitch_colours,ec='black',alpha=1,zorder=2)
+
+        ax.set_xlim((-25,25))
+        ax.set_ylim((-25,25))
+
+        ax.hlines(y=0,xmin=-50,xmax=50,color=colour_palette[8],alpha=0.5,linestyles='--',zorder=1)
+        ax.vlines(x=0,ymin=-50,ymax=50,color=colour_palette[8],alpha=0.5,linestyles='--',zorder=1)
+        ax.set_xlabel('Horizontal Break (in)', fontdict=font_properties_axes)
+        ax.set_ylabel('Induced Vertical Break (in)', fontdict=font_properties_axes)
+        ax.set_title("Pitch Breaks",fontdict=font_properties_titles)
+
+
+        ax.get_legend().remove()
+
+
+        # ax1.set_xticklabels(ax1.get_xticks(), fontdict=font_properties)
+        ax.set_xticklabels(ax.get_xticks(), fontdict=font_properties)
+
+        # ax1.set_yticklabels(ax1.get_yticks(), fontdict=font_properties)
+        ax.set_yticklabels(ax.get_yticks(), fontdict=font_properties)
+
+
+
+        #ax1.set_aspect('equal', adjustable='box')
+        if df['pitcher_hand'].values[0] == 'R':
+            ax.text(-24.5,-24.5,s='← Glove Side',fontstyle='italic',ha='left',va='bottom',
+                    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)
+            #ax.invert_xaxis()
+        if df['pitcher_hand'].values[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)
+            ax.text(-24.5,-24.5,s='Glove Side →',fontstyle='italic',ha='right',va='bottom',
+                        bbox=dict(facecolor='white', edgecolor='black'),fontsize=12,zorder=3)
+        ax.set_aspect('equal', adjustable='box')
+        #ax1.yaxis.set_major_formatter(FuncFormatter(lambda x, _: int(x)))
+        ax.xaxis.set_major_formatter(FuncFormatter(lambda x, _: int(x)))
+        ax.yaxis.set_major_formatter(FuncFormatter(lambda x, _: int(x)))
+
+### TABLE SUMMARY ###
+def table_summary(df,
+                  pitcher_id,
+                  ax,
+                  df_group,
+                  df_group_all,
+                  statcast_pitch_summary):
+        cmap_sum = matplotlib.colors.LinearSegmentedColormap.from_list("", ['#648FFF','#FFFFFF','#FFB000',])
+
+        ax.axis('off')
+        df_group['spin_direction_adj'] = [(x + 180) for x in df_group['spin_direction']]
+        #(((df_group.groupby('pitch_description').mean()[['spin_direction_adj']] %360 % 30 / 30 /100 *60).round(2) *10).round(0)//1.5/4 )
+        clock_time = ((df_group.groupby('pitch_description').mean()['spin_direction_adj']) %360 // 30 )+  (((df_group.groupby('pitch_description').mean()['spin_direction_adj'] %360 % 30 / 30 /100 *60).round(2) *10).round(0)//1.5/4 )
+   #     print('Clocks')
+   #     print(clock_time)
+        clock_time = (clock_time.astype(int) + clock_time%1*60/100).round(2).astype(str).str.replace('.',':').str.replace(':0',':00').str.replace(':3',':30').str.replace('0:','12:').str.replace('112:','10:').to_frame()
+        df_group = df_group.merge(right=clock_time,left_on='pitch_description',right_index=True,suffixes=['','_clock'])
+
+
+        plot_table = df_group[df_group['pitcher_id']==pitcher_id].sort_values(
+            by=['pitches'],ascending=False)[['pitch_description','pitches','start_speed','ivb',
+                    'hb', 'spin_rate','vaa', 'haa', 'vertical_release','horizontal_release',
+                    'extension','tj_stuff_plus','spin_direction_adj_clock','zone_percent','chase_percent','whiff_rate']]
+
+        # if df['pitcher_hand'].values[0] == 'L':
+        #     plot_table['hb'] = plot_table['hb']*-1
+
+        #if df['pitcher_hand'].values[0] == 'R':
+        plot_table['horizontal_release'] = plot_table['horizontal_release']*-1
+
+        plot_table['pitch_percent'] = plot_table['pitches'] / plot_table['pitches'].sum()
+
+        plot_table = plot_table[['pitch_description','pitches','pitch_percent','start_speed','ivb',
+                    'hb', 'spin_rate','vaa', 'haa', 'vertical_release','horizontal_release', 
+                    'extension','spin_direction_adj_clock','tj_stuff_plus','zone_percent','chase_percent','whiff_rate']]
+
+        plot_table_all = pd.DataFrame(data={'pitch_description': 'All',
+        'pitches': plot_table['pitches'].sum(),
+        'pitch_percent': 1.0,
+        'start_speed': '—',
+        'ivb': '—',
+        'hb': '—',
+        'spin_rate': '—',
+        'vaa': '—',
+        'haa': '—',
+        'vertical_release': '—',
+        'horizontal_release': '—',
+        'extension': df['extension'].mean(),
+        'spin_direction_adj_clock': '—',
+        'tj_stuff_plus': df[df['pitcher_id']==pitcher_id]['tj_stuff_plus'].mean(),
+        'zone_percent': df_group_all[df_group_all['pitcher_id']==pitcher_id]['zone_percent'].values[0],
+        'chase_percent': df_group_all[df_group_all['pitcher_id']==pitcher_id]['chase_percent'].values[0],
+        'whiff_rate': df_group_all[df_group_all['pitcher_id']==pitcher_id]['whiff_rate'].values[0],
+        
+        
+        },index=[0]
+        )
+
+        plot_table = pd.concat([plot_table,plot_table_all]).fillna('—')
+
+
+
+        plt.rcParams['font.family'] = 'Calibri'
+        table = ax.table(cellText=plot_table.values, colLabels=plot_table.columns, cellLoc='center',
+                        colWidths=[2.3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1], bbox=[0.04, 0, 0.92, 0.8])
+
+        min_font_size = 14
+        # Set table properties
+        table.auto_set_font_size(False)
+        #table.set_fontsize(min(min_font_size,max(min_font_size/((len(label_labels)/4)),10)))
+        table.set_fontsize(min_font_size)
+        table.scale(1, 0.5)
+
+        min_font_size = 20
+        # Set font size for values
+        # Adjust the font size as needed
+        for i in range(len(plot_table)+1):
+            for j in range(len(plot_table.columns)):
+                if i > 0:  # Skip the header row
+                    cell = table.get_celld()[i, j]
+                    cell.set_fontsize(min_font_size)
+
+
+        for i in range(len(plot_table)):
+            
+            if table.get_celld()[(i+1, 0)].get_text().get_text() != 'All':
+                table.get_celld()[(i+1, 0)].set_facecolor(pitch_colours[table.get_celld()[(i+1, 0)].get_text().get_text()])  # Header cell color
+                if table.get_celld()[(i+1, 0)].get_text().get_text() in ['Split-Finger','Slider','Changeup']:
+                    table.get_celld()[(i+1, 0)].set_text_props(color='#000000',fontweight='bold')
+                else:
+                    table.get_celld()[(i+1, 0)].set_text_props(color='#ffffff',fontweight='bold')
+                    if table.get_celld()[(i+1, 0)].get_text().get_text() == 'Four-Seam Fastball':
+                        table.get_celld()[(i+1, 0)].get_text().set_text('4-Seam Fastball')
+
+            select_df = statcast_pitch_summary[statcast_pitch_summary['pitch_description'] == plot_table['pitch_description'].values[i]]
+
+            normalize = mcolors.Normalize(vmin=select_df['start_speed'].mean()-select_df.pitch_velocity_std.mean(), 
+                                        vmax=select_df['start_speed'].mean()+select_df.pitch_velocity_std.mean()) # Define the range of values
+            
+            if table.get_celld()[(i+1, 3)].get_text().get_text() != '—':
+                table.get_celld()[(i+1, 3)].set_facecolor(get_color(float(table.get_celld()[(i+1, 3)].get_text().get_text()),normalize,cmap_sum))  # Header cell color
+          
+
+            cmap_sum = matplotlib.colors.LinearSegmentedColormap.from_list("", ['#648FFF','#FFFFFF','#FFB000',]) 
+            normalize = mcolors.Normalize(vmin=select_df['extension'].mean()*0.9, vmax=select_df['extension'].mean()*1.1)
+            if table.get_celld()[(i+1,11)].get_text().get_text() != '—':
+                table.get_celld()[(i+1,11)].set_facecolor(get_color(float(table.get_celld()[(i+1, 11)].get_text().get_text()),normalize,cmap_sum))  # Header cell color
+
+            cmap_sum = matplotlib.colors.LinearSegmentedColormap.from_list("", ['#648FFF','#FFFFFF','#FFB000',]) 
+            normalize = mcolors.Normalize(vmin=80, vmax=120)
+            print(normalize)
+            if table.get_celld()[(i+1,13)].get_text().get_text() != '—':
+                
+                table.get_celld()[(i+1,13)].set_facecolor(get_color(float(table.get_celld()[(i+1, 13)].get_text().get_text()),normalize,cmap_sum))  # Header cell color
+
+            cmap_sum = matplotlib.colors.LinearSegmentedColormap.from_list("", ['#648FFF','#FFFFFF','#FFB000',]) 
+            normalize = mcolors.Normalize(vmin=select_df['zone_percent'].mean()*0.7, vmax=select_df['zone_percent'].mean()*1.3)
+            if table.get_celld()[(i+1,14)].get_text().get_text() != '—':
+                table.get_celld()[(i+1,14)].set_facecolor(get_color(float(table.get_celld()[(i+1, 14)].get_text().get_text().strip('%')),normalize,cmap_sum))  # Header cell color
+
+            cmap_sum = matplotlib.colors.LinearSegmentedColormap.from_list("", ['#648FFF','#FFFFFF','#FFB000',]) 
+            normalize = mcolors.Normalize(vmin=select_df['chase_percent'].mean()*0.7, vmax=select_df['chase_percent'].mean()*1.3)
+            if table.get_celld()[(i+1,15)].get_text().get_text() != '—':
+                table.get_celld()[(i+1,15)].set_facecolor(get_color(float(table.get_celld()[(i+1, 15)].get_text().get_text().strip('%')),normalize,cmap_sum))  # Header cell color
+
+
+            cmap_sum = matplotlib.colors.LinearSegmentedColormap.from_list("", ['#648FFF','#FFFFFF','#FFB000',]) 
+            normalize = mcolors.Normalize(vmin=select_df['whiff_rate'].mean()*0.7, vmax=select_df['whiff_rate'].mean()*1.3)
+            if table.get_celld()[(i+1,16)].get_text().get_text() != '—':
+                table.get_celld()[(i+1,16)].set_facecolor(get_color(float(table.get_celld()[(i+1, 16)].get_text().get_text().strip('%')),normalize,cmap_sum))  # Header cell color
+
+            table.get_celld()[(len(plot_table), 0)].set_text_props(color='#000000',fontweight='bold') 
+            
+                
+            new_column_names = ['$\\bf{Pitch\ Name}$',
+            '$\\bf{Count}$',
+            '$\\bf{Pitch\%}$',
+            '$\\bf{Velocity}$',
+            '$\\bf{iVB}$',
+            '$\\bf{HB}$',
+            '$\\bf{Spin}$',
+            '$\\bf{VAA}$',
+            '$\\bf{HAA}$',
+            '$\\bf{vRel}$',    
+            '$\\bf{hRel}$',        
+
+            '$\\bf{Ext.}$',
+            '$\\bf{Axis}$',
+            '$\\bf{tjStuff+}$',
+            '$\\bf{Zone\%}$',
+            '$\\bf{Chase\%}$',
+            '$\\bf{Whiff\%}$',
+            ]
+
+            for i, col_name in enumerate(new_column_names):
+                table.get_celld()[(0, i)].get_text().set_text(col_name)
+
+        float_list = ['start_speed','ivb',
+                'hb', 'vaa', 'haa', 'vertical_release','horizontal_release', 'extension']
+        for fl in float_list:
+            # Subset of column names
+            subset_columns = [fl]
+            
+            # Get the list of column indices
+            column_indices = [plot_table.columns.get_loc(col) for col in subset_columns]
+            
+           # # print(column_indices)
+            for row_l in range(1,len(plot_table)+1):
+           #     print(row_l)
+                if table.get_celld()[(row_l,column_indices[0])].get_text().get_text() != '—':
+               #     print()
+               #     print(fl)
+                    table.get_celld()[(row_l,column_indices[0])].get_text().set_text('{:,.1f}'.format(float(table.get_celld()[(row_l,column_indices[0])].get_text().get_text().strip('%'))))
+
+
+
+        percent_list = ['pitch_percent','zone_percent','chase_percent','whiff_rate']
+        for fl in percent_list:
+            # Subset of column names
+            subset_columns = [fl]
+            
+            # Get the list of column indices
+            column_indices = [plot_table.columns.get_loc(col) for col in subset_columns]
+            
+           # # print(column_indices)
+            for row_l in range(1,len(plot_table)+1):
+           #     print(row_l)
+                if table.get_celld()[(row_l,column_indices[0])].get_text().get_text() != '—':
+                    
+               #     print(fl)
+                    table.get_celld()[(row_l,column_indices[0])].get_text().set_text('{:,.1%}'.format(float(table.get_celld()[(row_l,column_indices[0])].get_text().get_text().strip('%'))))
+
+
+        int_list = ['tj_stuff_plus','spin_rate']
+        for fl in int_list:
+            # Subset of column names
+            subset_columns = [fl]
+            
+            # Get the list of column indices
+            column_indices = [plot_table.columns.get_loc(col) for col in subset_columns]
+
+           # # print(column_indices)
+            for row_l in range(1,len(plot_table)+1):
+           #     print(row_l)
+                if table.get_celld()[(row_l,column_indices[0])].get_text().get_text() != '—':
+               #     print(fl)
+                    
+                    table.get_celld()[(row_l,column_indices[0])].get_text().set_text('{:,.0f}'.format(float(table.get_celld()[(row_l,column_indices[0])].get_text().get_text().strip('%'))))
+
+        return table
+
+### GROUED IVB CREATION ###
+def group_ivb_update(df,
+                     agg_list=['pitcher_id','pitcher_name','pitcher_hand','pitch_type','pitch_description']):
+    
+        grouped_ivb = df.groupby(agg_list).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'),
+        spin_direction = ('spin_direction','mean'),
+        tj_stuff_plus = ('tj_stuff_plus','mean'),
+        swings =  ('swings','sum'),
+        in_zone = ('in_zone','sum'),
+        out_zone = ('out_zone','sum'),
+        whiffs = ('whiffs','sum'),
+        zone_swing = ('zone_swing','sum'),
+        zone_contact = ('zone_contact','sum'),
+        ozone_swing = ('ozone_swing','sum'),
+        ozone_contact = ('ozone_contact','sum'),    
+        ).reset_index()
+
+
+        grouped_ivb['zone_contact_percent'] = [grouped_ivb.zone_contact[x]/grouped_ivb.zone_swing[x] if grouped_ivb.zone_swing[x] != 0 else np.nan for x in range(len(grouped_ivb))]
+
+        grouped_ivb['zone_swing_percent'] = [grouped_ivb.zone_swing[x]/grouped_ivb.in_zone[x] if grouped_ivb.pitches[x] != 0 else np.nan for x in range(len(grouped_ivb))]
+
+        grouped_ivb['zone_percent'] = [grouped_ivb.in_zone[x]/grouped_ivb.pitches[x] if grouped_ivb.pitches[x] != 0 else np.nan for x in range(len(grouped_ivb))]
+
+        grouped_ivb['chase_percent'] = [grouped_ivb.ozone_swing[x]/(grouped_ivb.pitches[x] - grouped_ivb.in_zone[x]) if (grouped_ivb.pitches[x]- grouped_ivb.in_zone[x]) != 0 else np.nan for x in range(len(grouped_ivb))]
+
+        grouped_ivb['chase_contact'] = [grouped_ivb.ozone_contact[x]/grouped_ivb.ozone_swing[x] if grouped_ivb.ozone_swing[x] != 0 else np.nan for x in range(len(grouped_ivb))]
+
+        grouped_ivb['swing_percent'] = [grouped_ivb.swings[x]/grouped_ivb.pitches[x] if grouped_ivb.pitches[x] != 0 else np.nan for x in range(len(grouped_ivb))]
+
+        grouped_ivb['whiff_rate'] = [grouped_ivb.whiffs[x]/grouped_ivb.swings[x] if grouped_ivb.swings[x] != 0 else np.nan for x in range(len(grouped_ivb))]
+
+        grouped_ivb['swstr_rate'] = [grouped_ivb.whiffs[x]/grouped_ivb.pitches[x] if grouped_ivb.pitches[x] != 0 else np.nan for x in range(len(grouped_ivb))]
+
+        return grouped_ivb
+
+
+####LHH
+def location_plot(df,ax,hand):
+        label_labels = df.sort_values(by=['prop','pitch_type'],ascending=[False,True]).pitch_description.unique()
+        j = 0
+        for label in label_labels:
+            
+            subset = df[(df['pitch_description'] == label)&(df['batter_hand'] == hand)]
+            print(label)
+            if len(subset) >= 5:
+                confidence_ellipse(subset['px'], subset['pz'], ax=ax,edgecolor =  pitch_colours[label],n_std=1.5,facecolor=  pitch_colours[label],alpha=0.3)
+                j=j+1
+            else:
+                j=j+1  
+
+        pitch_location_group = df[(df['batter_hand'] == hand)].groupby(['pitch_description']).agg(
+            pitches = ('start_speed','count'),
+            px = ('px','mean'),
+            pz = ('pz','mean')).reset_index()
+
+        pitch_location_group['pitch_percent'] = pitch_location_group['pitches']/pitch_location_group['pitches'].sum()
+
+
+        ## Location Plot
+        sns.scatterplot(ax=ax,x=pitch_location_group['px'],
+                                    y=pitch_location_group['pz'],
+                                    hue=pitch_location_group['pitch_description'],
+                                    palette=pitch_colours,ec='black',
+                                    s=pitch_location_group['pitch_percent']*750,
+                                    linewidth=2,
+                                    zorder=2)
+
+        ax.axis('square')
+        draw_line(ax,alpha_spot=0.75,catcher_p=False)
+        ax.axis('off')
+        ax.set_xlim((-2.75,2.75))
+        ax.set_ylim((-0.5,5))
+        if len(pitch_location_group['px'])>0:
+            ax.get_legend().remove()
+        ax.grid(False)
+        ax.set_title(f"Pitch Locations vs {hand}HB\n{pitch_location_group['pitches'].sum()} Pitches",fontdict=font_properties_titles)

statcast_pitch_summary.csv

@@ -0,0 +1,18 @@
+pitch_description,pitches,start_speed,ivb,hb,spin_rate,vaa,haa,horizontal_release,vertical_release,extension,swings,in_zone,out_zone,whiffs,zone_swing,zone_contact,ozone_swing,ozone_contact,zone_contact_percent,zone_swing_percent,zone_percent,chase_percent,chase_contact,swing_percent,whiff_rate,swstr_rate,pitch_velocity_std
+Changeup,78501,85.45244264,5.696969465,4.756409472,1788.814529,-7.397429532,0.066029801,-0.505147738,5.637483042,6.459312389,39508,30631,47870,12279,23324,18225,16184,9004,0.781383982,0.761450818,0.390198851,0.338082306,0.556351953,0.503280213,0.310797813,0.15641839,3.411101475
+Curveball,51673,79.28082171,-9.353269599,-3.755365471,2529.177413,-9.685324545,1.128810646,-0.615065727,5.935777432,6.356118766,21550,22503,29170,6681,13243,11063,8307,3806,0.835384732,0.588499311,0.435488553,0.284778882,0.45816781,0.417045652,0.310023202,0.129293828,3.845559953
+Cutter,55802,89.23017813,7.67180567,-1.473115659,2387.582408,-6.38378616,1.393012805,-0.885454511,5.73043569,6.364762822,27663,28608,27194,6695,19891,16452,7772,4516,0.827107737,0.695295022,0.512669797,0.285798338,0.581060216,0.49573492,0.242020027,0.119977779,3.290564827
+Eephus,523,47.97782027,16.7292543,-0.099235182,1170.40153,-14.91983588,1.506952393,-1.3219283,7.275302765,4.554736692,227,184,339,7,135,131,92,89,0.97037037,0.733695652,0.351816444,0.271386431,0.967391304,0.434034417,0.030837004,0.013384321,6.869976111
+Fastball,1140,67.09807018,15.87526316,5.559912281,1638.396309,-8.730726579,1.203451128,-1.423913573,6.371107598,4.816106427,573,543,597,41,405,379,168,153,0.935802469,0.745856354,0.476315789,0.281407035,0.910714286,0.502631579,0.071553229,0.035964912,9.112324944
+Forkball,778,82.96773779,1.274164524,7.219151671,1079.151436,-8.98002479,1.264533775,-1.651045178,5.833003132,6.46649016,358,188,590,199,144,93,214,66,0.645833333,0.765957447,0.241645244,0.362711864,0.308411215,0.460154242,0.555865922,0.255784062,1.581383091
+Four-Seam Fastball,230963,94.190831,15.70507094,3.1856687,2282.171475,-4.780780532,0.546832454,-0.72858478,5.693779333,6.512547603,111297,125822,105141,24710,85724,69571,25573,17016,0.811569689,0.681311694,0.54477124,0.243225763,0.665389278,0.481882379,0.222018563,0.106986833,2.47865324
+Knuckle Ball,190,75.68631579,-1.973157895,3.434736842,336.9684211,-8.570861876,1.201227902,-1.463108102,5.626929407,6.28061513,81,93,97,20,63,48,18,13,0.761904762,0.677419355,0.489473684,0.18556701,0.722222222,0.426315789,0.24691358,0.105263158,4.960630412
+Knuckle Curve,12153,81.43644368,-9.543701144,-5.97670534,2469.155167,-9.592522092,1.924129612,-1.025192611,5.916888283,6.36037149,5439,5095,7058,1800,3147,2683,2292,956,0.852557992,0.617664377,0.419238048,0.324737886,0.417102967,0.447543816,0.330943188,0.148111577,3.335305502
+Screwball,74,80.18648649,-4.459459459,9.043243243,2094.554054,-8.648739106,-0.179827995,-1.153713198,6.063270539,6.211306526,34,33,41,5,24,23,10,6,0.958333333,0.727272727,0.445945946,0.243902439,0.6,0.459459459,0.147058824,0.067567568,1.450679985
+Sinker,110889,93.31860599,7.843805066,6.938142647,2149.451219,-5.886868132,0.131331991,-0.761006834,5.525340998,6.420015363,50199,61433,49456,7185,37708,33570,12491,9444,0.890262013,0.613806912,0.554004455,0.252567939,0.756064366,0.452695939,0.143130341,0.064794524,2.892717921
+Slider,126080,85.12149032,1.606287278,-3.060486199,2408.269843,-7.741990027,1.624081206,-0.917878953,5.66131706,6.416260991,60686,56660,69420,20416,38692,31069,21994,9201,0.802982529,0.682880339,0.449397208,0.316825122,0.418341366,0.481329315,0.336420262,0.161928934,3.327382065
+Slow Curve,51,59.1745098,-9.101960784,-0.780392157,2058.285714,-14.41006285,1.056678233,-0.636672072,6.687193223,5.631413586,21,15,36,1,13,13,8,7,1,0.866666667,0.294117647,0.222222222,0.875,0.411764706,0.047619048,0.019607843,11.82586729
+Slurve,2330,82.12420601,-3.000300429,-4.449828326,2523.909406,-8.360925975,1.378365433,-0.669493725,5.578432792,6.027864672,984,1068,1262,273,619,538,365,173,0.86914378,0.579588015,0.458369099,0.289223455,0.473972603,0.422317597,0.277439024,0.117167382,2.558741806
+Splitter,15569,86.61465733,3.256830882,10.44272593,1355.748708,-7.739259105,0.553210998,-1.537501892,5.729877252,6.425062745,8129,5689,9880,2825,4542,3517,3587,1787,0.77432849,0.798382844,0.365405614,0.36305668,0.498187901,0.522127304,0.34752122,0.181450318,3.210384888
+Sweeper,30959,81.87371039,1.235039891,-7.533357021,2573.086585,-7.702769263,2.197097666,-0.997430186,5.419746312,6.442381843,14382,13480,17479,4702,8883,7108,5499,2572,0.800180119,0.658976261,0.435414581,0.314606099,0.467721404,0.464549889,0.326936448,0.151878291,2.916945647
+All,717675,88.99915324,7.084329815,1.49919922,2248.528397,-6.5395245,0.826992658,-0.783178307,5.67100296,6.439312301,341131,352045,365630,87839,236557,194483,104574,58809,0.822140118,0.671951029,0.490535409,0.286010448,0.562367319,0.475327969,0.257493456,0.122393841,6.109454214

team_logos.csv

@@ -0,0 +1,32 @@
+id,city,name,franchise,abbreviation,imageAbbreviation,imageLink
+108,Los Angeles Angels,Angels,Los Angeles Angels,LAA,LAA,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/LAA.png&h=400&w=400
+109,Arizona Diamondbacks,D-backs,Arizona Diamondbacks,AZ,ARI,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/ARI.png&h=400&w=400
+110,Baltimore Orioles,Orioles,Baltimore Orioles,BAL,BAL,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/BAL.png&h=400&w=400
+111,Boston Red Sox,Red Sox,Boston Red Sox,BOS,BOS,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/BOS.png&h=400&w=400
+112,Chicago Cubs,Cubs,Chicago Cubs,CHC,CHC,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/CHC.png&h=400&w=400
+113,Cincinnati Reds,Reds,Cincinnati Reds,CIN,CIN,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/CIN.png&h=400&w=400
+114,Cleveland Guardians,Guardians,Cleveland Guardians,CLE,CLE,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/CLE.png&h=400&w=400
+115,Colorado Rockies,Rockies,Colorado Rockies,COL,COL,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/COL.png&h=400&w=400
+116,Detroit Tigers,Tigers,Detroit Tigers,DET,DET,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/DET.png&h=400&w=400
+117,Houston Astros,Astros,Houston Astros,HOU,HOU,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/HOU.png&h=400&w=400
+118,Kansas City Royals,Royals,Kansas City Royals,KC,KC,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/KC.png&h=400&w=400
+119,Los Angeles Dodgers,Dodgers,Los Angeles Dodgers,LAD,LAD,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/LAD.png&h=400&w=400
+120,Washington Nationals,Nationals,Washington Nationals,WSH,WSH,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/WSH.png&h=400&w=400
+121,New York Mets,Mets,New York Mets,NYM,NYM,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/NYM.png&h=400&w=400
+133,Oakland Athletics,Athletics,Oakland Athletics,OAK,OAK,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/OAK.png&h=400&w=400
+134,Pittsburgh Pirates,Pirates,Pittsburgh Pirates,PIT,PIT,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/PIT.png&h=400&w=400
+135,San Diego Padres,Padres,San Diego Padres,SD,SD,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/SD.png&h=400&w=400
+136,Seattle Mariners,Mariners,Seattle Mariners,SEA,SEA,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/SEA.png&h=400&w=400
+137,San Francisco Giants,Giants,San Francisco Giants,SF,SF,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/SF.png&h=400&w=400
+138,St. Louis Cardinals,Cardinals,St. Louis Cardinals,STL,STL,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/STL.png&h=400&w=400
+139,Tampa Bay Rays,Rays,Tampa Bay Rays,TB,TB,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/TB.png&h=400&w=400
+140,Texas Rangers,Rangers,Texas Rangers,TEX,TEX,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/TEX.png&h=400&w=400
+141,Toronto Blue Jays,Blue Jays,Toronto Blue Jays,TOR,TOR,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/TOR.png&h=400&w=400
+142,Minnesota Twins,Twins,Minnesota Twins,MIN,MIN,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/MIN.png&h=400&w=400
+143,Philadelphia Phillies,Phillies,Philadelphia Phillies,PHI,PHI,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/PHI.png&h=400&w=400
+144,Atlanta Braves,Braves,Atlanta Braves,ATL,ATL,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/ATL.png&h=400&w=400
+145,Chicago White Sox,White Sox,Chicago White Sox,CWS,CHW,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/CHW.png&h=400&w=400
+146,Miami Marlins,Marlins,Miami Marlins,MIA,MIA,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/MIA.png&h=400&w=400
+147,New York Yankees,Yankees,New York Yankees,NYY,NYY,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/NYY.png&h=400&w=400
+158,Milwaukee Brewers,Brewers,Milwaukee Brewers,MIL,MIL,https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/MIL.png&h=400&w=400
+11,MLB,MLB,Free Agent,FA,MLB,https://a.espncdn.com/combiner/i?img=/i/teamlogos/leagues/500/mlb.png?w=400&h=400&transparent=true