Upload 2 files

api_scraper.py

@@ -0,0 +1,872 @@
+import requests
+import polars as pl
+import numpy as np
+from datetime import datetime
+from tqdm import tqdm
+from pytz import timezone
+import re
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+
+class MLB_Scrape:
+
+    def __init__(self):
+        # Initialize your class here if needed
+        pass
+
+    def get_sport_id(self):
+        """
+        Retrieves the list of sports from the MLB API and processes it into a Polars DataFrame.
+        
+        Returns:
+        - df (pl.DataFrame): A DataFrame containing the sports information.
+        """
+        # Make API call to retrieve sports information
+        response = requests.get(url='https://statsapi.mlb.com/api/v1/sports').json()
+        
+        # Convert the JSON response into a Polars DataFrame
+        df = pl.DataFrame(response['sports'])
+        
+        return df
+
+    def get_sport_id_check(self, sport_id: int = 1):
+        """
+        Checks if the provided sport ID exists in the list of sports retrieved from the MLB API.
+        
+        Parameters:
+        - sport_id (int): The sport ID to check. Default is 1.
+        
+        Returns:
+        - bool: True if the sport ID exists, False otherwise. If False, prints the available sport IDs.
+        """
+        # Retrieve the list of sports from the MLB API
+        sport_id_df = self.get_sport_id()
+        
+        # Check if the provided sport ID exists in the DataFrame
+        if sport_id not in sport_id_df['id']:
+            print('Please Select a New Sport ID from the following')
+            print(sport_id_df)
+            return False
+        
+        return True
+
+
+    def get_game_types(self):
+        """
+        Retrieves the different types of MLB games from the MLB API and processes them into a Polars DataFrame.
+        
+        Returns:
+        - df (pl.DataFrame): A DataFrame containing the game types information.
+        """
+        # Make API call to retrieve game types information
+        response = requests.get(url='https://statsapi.mlb.com/api/v1/gameTypes').json()
+        
+        # Convert the JSON response into a Polars DataFrame
+        df = pl.DataFrame(response)
+        
+        return df
+
+    def get_schedule(self,
+                    year_input: list = [2024],
+                    sport_id: list = [1],
+                    game_type: list = ['R']):
+        
+        """
+        Retrieves the schedule of baseball games based on the specified parameters.
+        Parameters:
+        - year_input (list): A list of years to filter the schedule. Default is [2024].
+        - sport_id (list): A list of sport IDs to filter the schedule. Default is [1].
+        - game_type (list): A list of game types to filter the schedule. Default is ['R'].
+        Returns:
+        - game_df (pandas.DataFrame): A DataFrame containing the game schedule information, including game ID, date, time, away team, home team, game state, venue ID, and venue name. If the schedule length is 0, it returns a message indicating that different parameters should be selected.
+        """
+
+        # Type checks
+        if not isinstance(year_input, list) or not all(isinstance(year, int) for year in year_input):
+            raise ValueError("year_input must be a list of integers.")
+        if not isinstance(sport_id, list) or not all(isinstance(sid, int) for sid in sport_id):
+            raise ValueError("sport_id must be a list of integers.")
+
+        if not isinstance(game_type, list) or not all(isinstance(gt, str) for gt in game_type):
+            raise ValueError("game_type must be a list of strings.")
+
+        eastern = timezone('US/Eastern')
+
+        # Convert input lists to comma-separated strings
+        year_input_str = ','.join([str(x) for x in year_input])
+        sport_id_str = ','.join([str(x) for x in sport_id])
+        game_type_str = ','.join([str(x) for x in game_type])
+
+        # Make API call to retrieve game schedule
+        game_call = requests.get(url=f'https://statsapi.mlb.com/api/v1/schedule/?sportId={sport_id_str}&gameTypes={game_type_str}&season={year_input_str}&hydrate=lineup,players').json()
+        try:
+            # Extract relevant data from the API response
+            game_list = [item for sublist in [[y.get('gamePk') for y in x['games']] for x in game_call['dates']] for item in sublist]
+            time_list = [item for sublist in [[y.get('gameDate') for y in x['games']] for x in game_call['dates']] for item in sublist]
+            date_list = [item for sublist in [[y.get('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'].get('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'].get('name') for y in x['games']] for x in game_call['dates']] for item in sublist]
+            state_list = [item for sublist in [[y['status'].get('codedGameState') for y in x['games']] for x in game_call['dates']] for item in sublist]
+            venue_id = [item for sublist in [[y['venue'].get('id', None) for y in x['games']] for x in game_call['dates']] for item in sublist]
+            venue_name = [item for sublist in [[y['venue'].get('name') for y in x['games']] for x in game_call['dates']] for item in sublist]
+
+            # Create a Polars DataFrame with the extracted data
+            game_df = pl.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})
+
+        
+            # Check if the DataFrame is empty
+            if len(game_df) == 0:
+                print('Schedule Length of 0, please select different parameters.')
+                return None
+
+            # Convert date and time columns to appropriate formats
+            game_df = game_df.with_columns(
+                game_df['date'].str.to_date(),
+                game_df['time'].str.to_datetime().dt.convert_time_zone(eastern.zone).dt.strftime("%I:%M %p"))
+
+            # Remove duplicate games and sort by date
+            game_df = game_df.unique(subset='game_id').sort('date')
+
+            # Check again if the DataFrame is empty after processing
+            if len(game_df) == 0:
+                print('Schedule Length of 0, please select different parameters.')
+                return None
+        except KeyError:
+            print('No Data for Selected Parameters')
+            return None
+        
+
+        return game_df
+    
+
+    def get_data(self, game_list_input: list):
+        """
+        Retrieves live game data for a list of game IDs in parallel.
+        
+        Parameters:
+        - game_list_input (list): A list of game IDs for which to retrieve live data.
+        
+        Returns:
+        - data_total (list): A list of JSON responses containing live game data for each game ID.
+        """
+        data_total = []
+        print('This May Take a While. Progress Bar shows Completion of Data Retrieval.')
+        
+        def fetch_data(game_id):
+            r = requests.get(f'https://statsapi.mlb.com/api/v1.1/game/{game_id}/feed/live')
+            return r.json()
+        
+        with ThreadPoolExecutor() as executor:
+            futures = {executor.submit(fetch_data, game_id): game_id for game_id in game_list_input}
+            for future in tqdm(as_completed(futures), total=len(futures), desc="Processing", unit="iteration"):
+                data_total.append(future.result())
+        
+        return data_total
+
+    def get_data_df(self, data_list):
+        """
+        Converts a list of game data JSON objects into a Polars DataFrame.
+        
+        Parameters:
+        - data_list (list): A list of JSON objects containing game data.
+        
+        Returns:
+        - data_df (pl.DataFrame): A DataFrame containing the structured game data.
+        """
+        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 = []
+        strikes_after = []
+        balls_after = []
+        outs_after = []
+
+        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 = []
+        vb = []
+        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 = []
+
+        for data in data_list:
+            try:
+                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']:
+                            ab_number.append(ab_list['atBatIndex'] if 'atBatIndex' in ab_list else None)
+    
+                            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 None)
+                              if 'batter' in ab_list['matchup']:
+                                batter_name.append(ab_list['matchup']['batter']['fullName'] if 'fullName' in ab_list['matchup']['batter'] else None)
+                              else:
+                                batter_name.append(None)
+    
+                              batter_hand.append(ab_list['matchup']['batSide']['code'] if 'batSide' in ab_list['matchup'] else None)
+                              pitcher_id.append(ab_list['matchup']['pitcher']['id'] if 'pitcher' in ab_list['matchup'] else None)
+                              if 'pitcher' in ab_list['matchup']:
+                                pitcher_name.append(ab_list['matchup']['pitcher']['fullName'] if 'fullName' in ab_list['matchup']['pitcher'] else None)
+                              else:
+                                pitcher_name.append(None)
+                            
+                              pitcher_hand.append(ab_list['matchup']['pitchHand']['code'] if 'pitchHand' in ab_list['matchup'] else None)
+    
+    
+                            if ab_list['about']['isTopInning']:
+                                batter_team.append(data['gameData']['teams']['away']['abbreviation'] if 'away' in data['gameData']['teams'] else None)
+                                batter_team_id.append(data['gameData']['teams']['away']['id'] if 'away' in data['gameData']['teams'] else None)
+                                pitcher_team.append(data['gameData']['teams']['home']['abbreviation'] if 'home' in data['gameData']['teams'] else None)
+                                pitcher_team_id.append(data['gameData']['teams']['home']['id'] if 'home' in data['gameData']['teams'] else None)
+    
+                            else:
+                                batter_team.append(data['gameData']['teams']['home']['abbreviation'] if 'home' in data['gameData']['teams'] else None)
+                                batter_team_id.append(data['gameData']['teams']['home']['id'] if 'home' in data['gameData']['teams'] else None)
+                                pitcher_team.append(data['gameData']['teams']['away']['abbreviation'] if 'away' in data['gameData']['teams'] else None)
+                                pitcher_team_id.append(data['gameData']['teams']['away']['id'] if 'away' in data['gameData']['teams'] else None)
+    
+                            play_description.append(ab_list['playEvents'][n]['details']['description'] if 'description' in ab_list['playEvents'][n]['details'] else None)
+                            play_code.append(ab_list['playEvents'][n]['details']['code'] if 'code' in ab_list['playEvents'][n]['details'] else None)
+                            in_play.append(ab_list['playEvents'][n]['details']['isInPlay'] if 'isInPlay' in ab_list['playEvents'][n]['details'] else None)
+                            is_strike.append(ab_list['playEvents'][n]['details']['isStrike'] if 'isStrike' in ab_list['playEvents'][n]['details'] else None)
+    
+                            if 'details' in ab_list['playEvents'][n]:
+                                is_swing.append(True if ab_list['playEvents'][n]['details']['code'] in swing_list else None)
+                                is_whiff.append(True if ab_list['playEvents'][n]['details']['code'] in whiff_list else None)
+                            else:
+                                is_swing.append(None)
+                                is_whiff.append(None)
+    
+                            is_ball.append(ab_list['playEvents'][n]['details']['isOut'] if 'isOut' in ab_list['playEvents'][n]['details'] else None)
+                            is_review.append(ab_list['playEvents'][n]['details']['hasReview'] if 'hasReview' in ab_list['playEvents'][n]['details'] else None)
+                            pitch_type.append(ab_list['playEvents'][n]['details']['type']['code'] if 'type' in ab_list['playEvents'][n]['details'] else None)
+                            pitch_description.append(ab_list['playEvents'][n]['details']['type']['description'] if 'type' in ab_list['playEvents'][n]['details'] else None)
+    
+                            if ab_list['playEvents'][n]['pitchNumber'] == 1:
+                                strikes.append(0)
+                                balls.append(0)
+                                strikes_after.append(ab_list['playEvents'][n]['count']['strikes'] if 'strikes' in ab_list['playEvents'][n]['count'] else None)
+                                balls_after.append(ab_list['playEvents'][n]['count']['balls'] if 'balls' in ab_list['playEvents'][n]['count'] else None)
+                                outs.append(ab_list['playEvents'][n]['count']['outs'] if 'outs' in ab_list['playEvents'][n]['count'] else None)
+                                outs_after.append(ab_list['playEvents'][n]['count']['outs'] if 'outs' in ab_list['playEvents'][n]['count'] else None)
+    
+                            else:
+                                strikes.append(ab_list['playEvents'][n-1]['count']['strikes'] if 'strikes' in ab_list['playEvents'][n-1]['count'] else None)
+                                balls.append(ab_list['playEvents'][n-1]['count']['balls'] if 'balls' in ab_list['playEvents'][n-1]['count'] else None)
+                                outs.append(ab_list['playEvents'][n-1]['count']['outs'] if 'outs' in ab_list['playEvents'][n-1]['count'] else None)
+    
+                                strikes_after.append(ab_list['playEvents'][n]['count']['strikes'] if 'strikes' in ab_list['playEvents'][n]['count'] else None)
+                                balls_after.append(ab_list['playEvents'][n]['count']['balls'] if 'balls' in ab_list['playEvents'][n]['count'] else None)
+                                outs_after.append(ab_list['playEvents'][n]['count']['outs'] if 'outs' in ab_list['playEvents'][n]['count'] else None)
+    
+    
+                            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 None)
+                                end_speed.append(ab_list['playEvents'][n]['pitchData']['endSpeed'] if 'endSpeed' in ab_list['playEvents'][n]['pitchData'] else None)
+    
+                                sz_top.append(ab_list['playEvents'][n]['pitchData']['strikeZoneTop'] if 'strikeZoneTop' in ab_list['playEvents'][n]['pitchData'] else None)
+                                sz_bot.append(ab_list['playEvents'][n]['pitchData']['strikeZoneBottom'] if 'strikeZoneBottom' in ab_list['playEvents'][n]['pitchData'] else None)
+                                x.append(ab_list['playEvents'][n]['pitchData']['coordinates']['x'] if 'x' in ab_list['playEvents'][n]['pitchData']['coordinates'] else None)
+                                y.append(ab_list['playEvents'][n]['pitchData']['coordinates']['y'] if 'y' in ab_list['playEvents'][n]['pitchData']['coordinates'] else None)
+    
+                                ax.append(ab_list['playEvents'][n]['pitchData']['coordinates']['aX'] if 'aX' in ab_list['playEvents'][n]['pitchData']['coordinates'] else None)
+                                ay.append(ab_list['playEvents'][n]['pitchData']['coordinates']['aY'] if 'aY' in ab_list['playEvents'][n]['pitchData']['coordinates'] else None)
+                                az.append(ab_list['playEvents'][n]['pitchData']['coordinates']['aZ'] if 'aZ' in ab_list['playEvents'][n]['pitchData']['coordinates'] else None)
+                                pfxx.append(ab_list['playEvents'][n]['pitchData']['coordinates']['pfxX'] if 'pfxX' in ab_list['playEvents'][n]['pitchData']['coordinates'] else None)
+                                pfxz.append(ab_list['playEvents'][n]['pitchData']['coordinates']['pfxZ'] if 'pfxZ' in ab_list['playEvents'][n]['pitchData']['coordinates'] else None)
+                                px.append(ab_list['playEvents'][n]['pitchData']['coordinates']['pX'] if 'pX' in ab_list['playEvents'][n]['pitchData']['coordinates'] else None)
+                                pz.append(ab_list['playEvents'][n]['pitchData']['coordinates']['pZ'] if 'pZ' in ab_list['playEvents'][n]['pitchData']['coordinates'] else None)
+                                vx0.append(ab_list['playEvents'][n]['pitchData']['coordinates']['vX0'] if 'vX0' in ab_list['playEvents'][n]['pitchData']['coordinates'] else None)
+                                vy0.append(ab_list['playEvents'][n]['pitchData']['coordinates']['vY0'] if 'vY0' in ab_list['playEvents'][n]['pitchData']['coordinates'] else None)
+                                vz0.append(ab_list['playEvents'][n]['pitchData']['coordinates']['vZ0'] if 'vZ0' in ab_list['playEvents'][n]['pitchData']['coordinates'] else None)
+                                x0.append(ab_list['playEvents'][n]['pitchData']['coordinates']['x0'] if 'x0' in ab_list['playEvents'][n]['pitchData']['coordinates'] else None)
+                                y0.append(ab_list['playEvents'][n]['pitchData']['coordinates']['y0'] if 'y0' in ab_list['playEvents'][n]['pitchData']['coordinates'] else None)
+                                z0.append(ab_list['playEvents'][n]['pitchData']['coordinates']['z0'] if 'z0' in ab_list['playEvents'][n]['pitchData']['coordinates'] else None)
+    
+                                zone.append(ab_list['playEvents'][n]['pitchData']['zone'] if 'zone' in ab_list['playEvents'][n]['pitchData'] else None)
+                                type_confidence.append(ab_list['playEvents'][n]['pitchData']['typeConfidence'] if 'typeConfidence' in ab_list['playEvents'][n]['pitchData'] else None)
+                                plate_time.append(ab_list['playEvents'][n]['pitchData']['plateTime'] if 'plateTime' in ab_list['playEvents'][n]['pitchData'] else None)
+                                extension.append(ab_list['playEvents'][n]['pitchData']['extension'] if 'extension' in ab_list['playEvents'][n]['pitchData'] else None)
+    
+                                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 None)
+                                    spin_direction.append(ab_list['playEvents'][n]['pitchData']['breaks']['spinDirection'] if 'spinDirection' in ab_list['playEvents'][n]['pitchData']['breaks'] else None)
+                                    vb.append(ab_list['playEvents'][n]['pitchData']['breaks']['breakVertical'] if 'breakVertical' in ab_list['playEvents'][n]['pitchData']['breaks'] else None)                               
+                                    ivb.append(ab_list['playEvents'][n]['pitchData']['breaks']['breakVerticalInduced'] if 'breakVerticalInduced' in ab_list['playEvents'][n]['pitchData']['breaks'] else None)
+                                    hb.append(ab_list['playEvents'][n]['pitchData']['breaks']['breakHorizontal'] if 'breakHorizontal' in ab_list['playEvents'][n]['pitchData']['breaks'] else None)
+    
+                            else:
+                                start_speed.append(None)
+                                end_speed.append(None)
+    
+                                sz_top.append(None)
+                                sz_bot.append(None)
+                                x.append(None)
+                                y.append(None)
+    
+                                ax.append(None)
+                                ay.append(None)
+                                az.append(None)
+                                pfxx.append(None)
+                                pfxz.append(None)
+                                px.append(None)
+                                pz.append(None)
+                                vx0.append(None)
+                                vy0.append(None)
+                                vz0.append(None)
+                                x0.append(None)
+                                y0.append(None)
+                                z0.append(None)
+    
+                                zone.append(None)
+                                type_confidence.append(None)
+                                plate_time.append(None)
+                                extension.append(None)
+                                spin_rate.append(None)
+                                spin_direction.append(None)
+                                vb.append(None)
+                                ivb.append(None)
+                                hb.append(None)
+    
+                            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 None)
+                                launch_angle.append(ab_list['playEvents'][n]['hitData']['launchAngle'] if 'launchAngle' in ab_list['playEvents'][n]['hitData'] else None)
+                                launch_distance.append(ab_list['playEvents'][n]['hitData']['totalDistance'] if 'totalDistance' in ab_list['playEvents'][n]['hitData'] else None)
+                                launch_location.append(ab_list['playEvents'][n]['hitData']['location'] if 'location' in ab_list['playEvents'][n]['hitData'] else None)
+    
+                                trajectory.append(ab_list['playEvents'][n]['hitData']['trajectory'] if 'trajectory' in ab_list['playEvents'][n]['hitData'] else None)
+                                hardness.append(ab_list['playEvents'][n]['hitData']['hardness'] if 'hardness' in ab_list['playEvents'][n]['hitData'] else None)
+                                hit_x.append(ab_list['playEvents'][n]['hitData']['coordinates']['coordX'] if 'coordX' in ab_list['playEvents'][n]['hitData']['coordinates'] else None)
+                                hit_y.append(ab_list['playEvents'][n]['hitData']['coordinates']['coordY'] if 'coordY' in ab_list['playEvents'][n]['hitData']['coordinates'] else None)
+                            else:
+                                launch_speed.append(None)
+                                launch_angle.append(None)
+                                launch_distance.append(None)
+                                launch_location.append(None)
+                                trajectory.append(None)
+                                hardness.append(None)
+                                hit_x.append(None)
+                                hit_y.append(None)
+    
+                            index_play.append(ab_list['playEvents'][n]['index'] if 'index' in ab_list['playEvents'][n] else None)
+                            play_id.append(ab_list['playEvents'][n]['playId'] if 'playId' in ab_list['playEvents'][n] else None)
+                            start_time.append(ab_list['playEvents'][n]['startTime'] if 'startTime' in ab_list['playEvents'][n] else None)
+                            end_time.append(ab_list['playEvents'][n]['endTime'] if 'endTime' in ab_list['playEvents'][n] else None)
+                            is_pitch.append(ab_list['playEvents'][n]['isPitch'] if 'isPitch' in ab_list['playEvents'][n] else None)
+                            type_type.append(ab_list['playEvents'][n]['type'] if 'type' in ab_list['playEvents'][n] else None)
+    
+    
+    
+                            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 None)
+                                event.append(data['liveData']['plays']['allPlays'][ab_id]['result']['event'] if 'event' in data['liveData']['plays']['allPlays'][ab_id]['result'] else None)
+                                event_type.append(data['liveData']['plays']['allPlays'][ab_id]['result']['eventType'] if 'eventType' in data['liveData']['plays']['allPlays'][ab_id]['result'] else None)
+                                rbi.append(data['liveData']['plays']['allPlays'][ab_id]['result']['rbi'] if 'rbi' in data['liveData']['plays']['allPlays'][ab_id]['result'] else None)
+                                away_score.append(data['liveData']['plays']['allPlays'][ab_id]['result']['awayScore'] if 'awayScore' in data['liveData']['plays']['allPlays'][ab_id]['result'] else None)
+                                home_score.append(data['liveData']['plays']['allPlays'][ab_id]['result']['homeScore'] if 'homeScore' in data['liveData']['plays']['allPlays'][ab_id]['result'] else None)
+                                is_out.append(data['liveData']['plays']['allPlays'][ab_id]['result']['isOut'] if 'isOut' in data['liveData']['plays']['allPlays'][ab_id]['result'] else None)
+    
+                            else:
+    
+                                type_ab.append(None)
+                                event.append(None)
+                                event_type.append(None)
+                                rbi.append(None)
+                                away_score.append(None)
+                                home_score.append(None)
+                                is_out.append(None)
+    
+                        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 None)
+                            batter_name.append(ab_list['matchup']['batter']['fullName'] if 'batter' in ab_list['matchup'] else None)
+                            batter_hand.append(ab_list['matchup']['batSide']['code'] if 'batSide' in ab_list['matchup'] else None)
+                            pitcher_id.append(ab_list['matchup']['pitcher']['id'] if 'pitcher' in ab_list['matchup'] else None)
+                            pitcher_name.append(ab_list['matchup']['pitcher']['fullName'] if 'pitcher' in ab_list['matchup'] else None)
+                            pitcher_hand.append(ab_list['matchup']['pitchHand']['code'] if 'pitchHand' in ab_list['matchup'] else None)
+                            if ab_list['about']['isTopInning']:
+                                batter_team.append(data['gameData']['teams']['away']['abbreviation'] if 'away' in data['gameData']['teams'] else None)
+                                batter_team_id.append(data['gameData']['teams']['away']['id'] if 'away' in data['gameData']['teams'] else None)
+                                pitcher_team.append(data['gameData']['teams']['home']['abbreviation'] if 'home' in data['gameData']['teams'] else None)
+                                pitcher_team_id.append(data['gameData']['teams']['away']['id'] if 'away' in data['gameData']['teams'] else None)
+                            else:
+                                batter_team.append(data['gameData']['teams']['home']['abbreviation'] if 'home' in data['gameData']['teams'] else None)
+                                batter_team_id.append(data['gameData']['teams']['home']['id'] if 'home' in data['gameData']['teams'] else None)
+                                pitcher_team.append(data['gameData']['teams']['away']['abbreviation'] if 'away' in data['gameData']['teams'] else None)
+                                pitcher_team_id.append(data['gameData']['teams']['home']['id'] if 'home' in data['gameData']['teams'] else None)
+    
+                            play_description.append(None)
+                            play_code.append(None)
+                            in_play.append(None)
+                            is_strike.append(None)
+                            is_ball.append(None)
+                            is_review.append(None)
+                            pitch_type.append(None)
+                            pitch_description.append(None)
+                            strikes.append(ab_list['playEvents'][n]['count']['balls'] if 'balls' in ab_list['playEvents'][n]['count'] else None)
+                            balls.append(ab_list['playEvents'][n]['count']['strikes'] if 'strikes' in ab_list['playEvents'][n]['count'] else None)
+                            outs.append(ab_list['playEvents'][n]['count']['outs'] if 'outs' in ab_list['playEvents'][n]['count'] else None)
+                            strikes_after.append(ab_list['playEvents'][n]['count']['balls'] if 'balls' in ab_list['playEvents'][n]['count'] else None)
+                            balls_after.append(ab_list['playEvents'][n]['count']['strikes'] if 'strikes' in ab_list['playEvents'][n]['count'] else None)
+                            outs_after.append(ab_list['playEvents'][n]['count']['outs'] if 'outs' in ab_list['playEvents'][n]['count'] else None)
+                            index_play.append(ab_list['playEvents'][n]['index'] if 'index' in ab_list['playEvents'][n] else None)
+                            play_id.append(ab_list['playEvents'][n]['playId'] if 'playId' in ab_list['playEvents'][n] else None)
+                            start_time.append(ab_list['playEvents'][n]['startTime'] if 'startTime' in ab_list['playEvents'][n] else None)
+                            end_time.append(ab_list['playEvents'][n]['endTime'] if 'endTime' in ab_list['playEvents'][n] else None)
+                            is_pitch.append(ab_list['playEvents'][n]['isPitch'] if 'isPitch' in ab_list['playEvents'][n] else None)
+                            type_type.append(ab_list['playEvents'][n]['type'] if 'type' in ab_list['playEvents'][n] else None)
+    
+    
+    
+                            is_swing.append(None)
+                            is_whiff.append(None)
+                            start_speed.append(None)
+                            end_speed.append(None)
+                            sz_top.append(None)
+                            sz_bot.append(None)
+                            x.append(None)
+                            y.append(None)
+                            ax.append(None)
+                            ay.append(None)
+                            az.append(None)
+                            pfxx.append(None)
+                            pfxz.append(None)
+                            px.append(None)
+                            pz.append(None)
+                            vx0.append(None)
+                            vy0.append(None)
+                            vz0.append(None)
+                            x0.append(None)
+                            y0.append(None)
+                            z0.append(None)
+                            zone.append(None)
+                            type_confidence.append(None)
+                            plate_time.append(None)
+                            extension.append(None)
+                            spin_rate.append(None)
+                            spin_direction.append(None)
+                            vb.append(None)
+                            ivb.append(None)
+                            hb.append(None)
+                            launch_speed.append(None)
+                            launch_angle.append(None)
+                            launch_distance.append(None)
+                            launch_location.append(None)
+                            trajectory.append(None)
+                            hardness.append(None)
+                            hit_x.append(None)
+                            hit_y.append(None)
+                            type_ab.append(None)
+                            ab_number.append(None)
+    
+                            rbi.append(None)
+                            away_score.append(None)
+                            home_score.append(None)
+                            is_out.append(None)
+
+            except KeyError:
+                print(f"No Data for Game")
+        
+        df  = pl.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,
+            'ab_number':ab_number,
+            '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,
+            'strikes_after':strikes_after,
+            'balls_after':balls_after,
+            'outs_after':outs_after,            
+            '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,
+            'vb':vb,
+            '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,
+
+            },strict=False
+            )
+
+        return df
+
+    def get_teams(self):
+        """
+        Retrieves information about MLB teams from the MLB API and processes it into a Polars DataFrame.
+        
+        Returns:
+        - mlb_teams_df (pl.DataFrame): A DataFrame containing team information, including team ID, city, name, franchise, abbreviation, parent organization ID, parent organization name, league ID, and league name.
+        """
+        # Make API call to retrieve team information
+        teams = requests.get(url='https://statsapi.mlb.com/api/v1/teams/').json()
+
+        # Extract relevant data from the API response
+        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 Polars DataFrame with the extracted data
+        mlb_teams_df = pl.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
+                                        }).unique().drop_nulls(subset=['team_id']).sort('team_id')
+
+        # Fill missing parent organization IDs with team IDs
+        mlb_teams_df = mlb_teams_df.with_columns(
+            pl.when(pl.col('parent_org_id').is_null())
+            .then(pl.col('team_id'))
+            .otherwise(pl.col('parent_org_id'))
+            .alias('parent_org_id')
+        )
+
+        # Fill missing parent organization names with franchise names
+        mlb_teams_df = mlb_teams_df.with_columns(
+            pl.when(pl.col('parent_org').is_null())
+            .then(pl.col('franchise'))
+            .otherwise(pl.col('parent_org'))
+            .alias('parent_org')
+        )
+
+        # Create a dictionary for mapping team IDs to abbreviations
+        abbreviation_dict = mlb_teams_df.select(['team_id', 'abbreviation']).to_dict(as_series=False)
+        abbreviation_map = {k: v for k, v in zip(abbreviation_dict['team_id'], abbreviation_dict['abbreviation'])}
+
+        # Create a DataFrame for parent organization abbreviations
+        abbreviation_df = mlb_teams_df.select(['team_id', 'abbreviation']).rename({'team_id': 'parent_org_id', 'abbreviation': 'parent_org_abbreviation'})
+
+        # Join the parent organization abbreviations with the main DataFrame
+        mlb_teams_df = mlb_teams_df.join(abbreviation_df, on='parent_org_id', how='left')
+
+        return mlb_teams_df
+
+    def get_leagues(self):
+        """
+        Retrieves information about MLB leagues from the MLB API and processes it into a Polars DataFrame.
+        
+        Returns:
+        - leagues_df (pl.DataFrame): A DataFrame containing league information, including league ID, league name, league abbreviation, and sport ID.
+        """
+        # Make API call to retrieve league information
+        leagues = requests.get(url='https://statsapi.mlb.com/api/v1/leagues/').json()
+
+        # Extract relevant data from the API response
+        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']]
+
+        # Create a Polars DataFrame with the extracted data
+        leagues_df = pl.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: int, 
+                              season: int, 
+                              start_date: str = None, 
+                              end_date: str = None, 
+                              sport_id: int = 1, 
+                              game_type: list = ['R'],
+                              pitching: bool = True):
+        """
+        Retrieves a list of game IDs for a specific player in a given season.
+        
+        Parameters:
+        - player_id (int): The ID of the player.
+        - season (int): The season year for which to retrieve the game list.
+        - start_date (str): The start date (YYYY-MM-DD) of the range (default is January 1st of the specified season).
+        - end_date (str): The end date (YYYY-MM-DD) of the range (default is December 31st of the specified season).
+        - sport_id (int): The ID of the sport for which to retrieve player data.
+        - game_type (list): A list of game types to filter the schedule. Default is ['R'].
+        - pitching (bool): Return pitching games.
+        
+        Returns:
+        - player_game_list (list): A list of game IDs in which the player participated during the specified season.
+        """
+        # Set default start and end dates if not provided
+        if not start_date:
+            start_date = f'{season}-01-01'
+        if not end_date:
+            end_date = f'{season}-12-31'
+
+        # Determine the group based on the pitching flag
+        group = 'pitching' if pitching else 'hitting'
+
+        # Validate date format
+        date_pattern = re.compile(r'^\d{4}-\d{2}-\d{2}$')
+        if not date_pattern.match(start_date):
+            raise ValueError(f"start_date {start_date} is not in YYYY-MM-DD format")
+        if not date_pattern.match(end_date):
+            raise ValueError(f"end_date {end_date} is not in YYYY-MM-DD format")
+
+        # Convert game type list to a comma-separated string
+        game_type_str = ','.join([str(x) for x in game_type])
+
+        # Make API call to retrieve player game logs
+        response = requests.get(url=f'http://statsapi.mlb.com/api/v1/people/{player_id}?hydrate=stats(group={group},type=gameLog,season={season},startDate={start_date},endDate={end_date},sportId={sport_id},gameType=[{game_type_str}]),hydrations').json()
+        
+        # Check if stats are available in the response
+        if 'stats' not in response['people'][0]:
+            print(f'No {group} games found for player {player_id} in season {season}')
+            return []
+
+        # Extract game IDs from the API response
+        player_game_list = [x['game']['gamePk'] for x in response['people'][0]['stats'][0]['splits']]
+        
+        return player_game_list
+        
+    def get_players(self, sport_id: int, season: int, game_type: list = ['R']):
+        """
+        Retrieves data frame of players in a given league
+
+        Parameters:
+        - sport_id (int): The ID of the sport for which to retrieve player data.
+        - season (int): The season year for which to retrieve player data.
+        - game_type (list): A list of game types to filter the players. Default is ['R'].
+
+        Returns:
+        - player_df (pl.DataFrame): A DataFrame containing player information, including player ID, name, position, team, and age.
+        """
+        game_type_str = ','.join([str(x) for x in game_type])
+
+        # If game type is 'S', fetch data from a different endpoint
+        if game_type_str == 'S':
+            # Fetch pitcher data
+            pitcher_data = requests.get(f'https://bdfed.stitch.mlbinfra.com/bdfed/stats/player?&env=prod&season={season}&sportId=1&stats=season&group=pitching&gameType=S&limit=1000000&offset=0&sortStat=inningsPitched&order=asc').json()
+            fullName_list = [x['playerFullName'] for x in pitcher_data['stats']]
+            firstName_list = [x['playerFirstName'] for x in pitcher_data['stats']]
+            lastName_list = [x['playerLastName'] for x in pitcher_data['stats']]
+            id_list = [x['playerId'] for x in pitcher_data['stats']]
+            position_list = [x['primaryPositionAbbrev'] for x in pitcher_data['stats']]
+            team_list = [x['teamId'] for x in pitcher_data['stats']]
+            
+            df_pitcher = pl.DataFrame(data={
+                'player_id': id_list,
+                'first_name': firstName_list,
+                'last_name': lastName_list,
+                'name': fullName_list,
+                'position': position_list,
+                'team': team_list
+            })
+            
+            # Fetch batter data
+            batter_data = requests.get(f'https://bdfed.stitch.mlbinfra.com/bdfed/stats/player?&env=prod&season={season}&sportId=1&stats=season&group=hitting&gameType=S&limit=1000000&offset=0').json()
+            fullName_list = [x['playerFullName'] for x in batter_data['stats']]
+            firstName_list = [x['playerFirstName'] for x in batter_data['stats']]
+            lastName_list = [x['playerLastName'] for x in batter_data['stats']]
+            id_list = [x['playerId'] for x in batter_data['stats']]
+            position_list = [x['primaryPositionAbbrev'] for x in batter_data['stats']]
+            team_list = [x['teamId'] for x in batter_data['stats']]
+            
+            df_batter = pl.DataFrame(data={
+                'player_id': id_list,
+                'first_name': firstName_list,
+                'last_name': lastName_list,
+                'name': fullName_list,
+                'position': position_list,
+                'team': team_list
+            })
+
+            # Combine pitcher and batter data
+            df = pl.concat([df_pitcher, df_batter]).unique().drop_nulls(subset=['player_id']).sort('player_id')
+        
+        else:
+            # Fetch player data for other game types
+            player_data = requests.get(url=f'https://statsapi.mlb.com/api/v1/sports/{sport_id}/players?season={season}&gameType=[{game_type_str}]').json()['people']
+
+            # Extract relevant data
+            fullName_list = [x['fullName'] for x in player_data]
+            firstName_list = [x['firstName'] for x in player_data]
+            lastName_list = [x['lastName'] for x in player_data]
+            id_list = [x['id'] for x in player_data]
+            position_list = [x['primaryPosition']['abbreviation'] if 'primaryPosition' in x else None for x in player_data]
+            team_list = [x['currentTeam']['id'] if 'currentTeam' in x else None for x in player_data]
+            weight_list = [x['weight'] if 'weight' in x else None for x in player_data]
+            height_list = [x['height'] if 'height' in x else None for x in player_data]
+            age_list = [x['currentAge'] if 'currentAge' in x else None for x in player_data]
+            birthDate_list = [x['birthDate'] if 'birthDate' in x else None for x in player_data]
+    
+            df = pl.DataFrame(data={
+                'player_id': id_list,
+                'first_name': firstName_list,
+                'last_name': lastName_list,
+                'name': fullName_list,
+                'position': position_list,
+                'team': team_list,
+                'weight': weight_list,
+                'height': height_list,
+                'age': age_list,
+                'birthDate': birthDate_list
+            })
+                
+        return df

app.py

@@ -1,359 +1,472 @@
-import polars as pl
-import numpy as np
-import pandas as pd
-import api_scraper
-scrape = api_scraper.MLB_Scrape()
-from functions import df_update
-from functions import pitch_summary_functions
-update = df_update.df_update()
-from stuff_model import feature_engineering as fe
-from stuff_model import stuff_apply
-import requests
-import joblib
-from matplotlib.gridspec import GridSpec
-from shiny import App, reactive, ui, render
-from shiny.ui import h2, tags
-import matplotlib.pyplot as plt
-import matplotlib.gridspec as gridspec
-import seaborn as sns
-from functions.pitch_summary_functions import *
-from shiny import App, reactive, ui, render
-from shiny.ui import h2, tags
-
-colour_palette = ['#FFB000','#648FFF','#785EF0',
-                  '#DC267F','#FE6100','#3D1EB2','#894D80','#16AA02','#B5592B','#A3C1ED']
-
-
-year_list = [2017,2018,2019,2020,2021,2022,2023,2024]
-
-
-
-level_dict =  {'1':'MLB',
-               '11':'AAA',
-               '12':'AA',
-               '13':'A+',
-               '14':'A',
-               '17':'AFL',
-               '22':'College',
-               '21':'Prospects',
-               '51':'International' }
-
-function_dict={
-    'velocity_kdes':'Velocity Distributions',
-    'break_plot':'Pitch Movement',
-    'tj_stuff_roling':'Rolling tjStuff+ by Pitch',
-    'tj_stuff_roling_game':'Rolling tjStuff+ by Game',
-    'location_plot_lhb':'Locations vs LHB',
-    'location_plot_rhb':'Locations vs RHB',
-}
-
-
-split_dict =  {'all':'All',
-               'left':'LHH',
-               'right':'RHH'}
-
-split_dict_hand =  {'all':['L','R'],
-               'left':['L'],
-               'right':['R']}
-
-
-type_dict =  {'R':'Regular Season',
-               'S':'Spring',
-               'P':'Playoffs' }
-
-
-
-# List of MLB teams and their corresponding ESPN logo URLs
-mlb_teams = [
-    {"team": "AZ", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/ari.png&h=500&w=500"},
-    {"team": "ATH", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/oak.png&h=500&w=500"},
-    {"team": "ATL", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/atl.png&h=500&w=500"},
-    {"team": "BAL", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/bal.png&h=500&w=500"},
-    {"team": "BOS", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/bos.png&h=500&w=500"},
-    {"team": "CHC", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/chc.png&h=500&w=500"},
-    {"team": "CWS", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/chw.png&h=500&w=500"},
-    {"team": "CIN", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/cin.png&h=500&w=500"},
-    {"team": "CLE", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/cle.png&h=500&w=500"},
-    {"team": "COL", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/col.png&h=500&w=500"},
-    {"team": "DET", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/det.png&h=500&w=500"},
-    {"team": "HOU", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/hou.png&h=500&w=500"},
-    {"team": "KC", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/kc.png&h=500&w=500"},
-    {"team": "LAA", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/laa.png&h=500&w=500"},
-    {"team": "LAD", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/lad.png&h=500&w=500"},
-    {"team": "MIA", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/mia.png&h=500&w=500"},
-    {"team": "MIL", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/mil.png&h=500&w=500"},
-    {"team": "MIN", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/min.png&h=500&w=500"},
-    {"team": "NYM", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/nym.png&h=500&w=500"},
-    {"team": "NYY", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/nyy.png&h=500&w=500"},
-    {"team": "PHI", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/phi.png&h=500&w=500"},
-    {"team": "PIT", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/pit.png&h=500&w=500"},
-    {"team": "SD", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/sd.png&h=500&w=500"},
-    {"team": "SF", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/sf.png&h=500&w=500"},
-    {"team": "SEA", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/sea.png&h=500&w=500"},
-    {"team": "STL", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/stl.png&h=500&w=500"},
-    {"team": "TB", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/tb.png&h=500&w=500"},
-    {"team": "TEX", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/tex.png&h=500&w=500"},
-    {"team": "TOR", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/tor.png&h=500&w=500"},
-    {"team": "WSH", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/wsh.png&h=500&w=500"},
-    {"team": "ZZZ", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/leagues/500/mlb.png&w=500&h=500"}   
-]
-
-
-df_image = pd.DataFrame(mlb_teams)
-image_dict = df_image.set_index('team')['logo_url'].to_dict()
-image_dict_flip = df_image.set_index('logo_url')['team'].to_dict()
-
-from shiny import App, reactive, ui, render
-from shiny.ui import h2, tags
-
-# Define the UI layout for the app
-app_ui = ui.page_fluid(
-    ui.layout_sidebar(
-        ui.panel_sidebar(
-            # Row for selecting season and level
-            ui.row(
-                ui.column(4, ui.input_select('year_input', 'Select Season', year_list, selected=2024)),
-                ui.column(4, ui.input_select('level_input', 'Select Level', level_dict)),
-                ui.column(4, ui.input_select('type_input', 'Select Type', type_dict,selected='R'))
-            ),
-            # Row for the action button to get player list
-            ui.row(ui.input_action_button("player_button", "Get Player List", class_="btn-primary")),
-            # Row for selecting the player
-            ui.row(ui.column(12, ui.output_ui('player_select_ui', 'Select Player'))),
-            # Row for selecting the date range
-            ui.row(ui.column(12, ui.output_ui('date_id', 'Select Date'))),
-
-            # Rows for selecting plots and split options
-            ui.row(
-                ui.column(4, ui.input_select('plot_id_1', 'Plot Left', function_dict, multiple=False, selected='velocity_kdes')),
-                ui.column(4, ui.input_select('plot_id_2', 'Plot Middle', function_dict, multiple=False, selected='tj_stuff_roling')),
-                ui.column(4, ui.input_select('plot_id_3', 'Plot Right', function_dict, multiple=False, selected='break_plot'))
-            ),
-            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=50))
-            ),
-            ui.row(
-                ui.column(6, ui.input_switch("switch", "Custom Team?", False)),
-                ui.column(6, ui.input_select('logo_select', 'Select Custom Logo', image_dict_flip, multiple=False))
-            ),
-            
-            # Row for the action button to generate plot
-            ui.row(ui.input_action_button("generate_plot", "Generate Plot", class_="btn-primary")),
-        ),
-                
-        ui.panel_main(
-            ui.navset_tab(
-                # Tab for game summary plot
-                ui.nav("Pitching Summary",
-                       ui.output_text("status"),
-                       ui.output_plot('plot', width='2100px', height='2100px')
-                ),
-            )
-        )
-    )
-)
-
-
-def server(input, output, session):
-
-    @reactive.calc
-    @reactive.event(input.pitcher_id, input.date_id,input.split_id)
-    def cached_data():
-
-        year_input = int(input.year_input())
-        sport_id = int(input.level_input())
-        player_input = int(input.pitcher_id())
-        start_date = str(input.date_id()[0])
-        end_date = str(input.date_id()[1])
-        # Simulate an expensive data operation
-        game_list  = scrape.get_player_games_list(sport_id = sport_id,
-                                                season = year_input, 
-                                                player_id = player_input,
-                                                start_date = start_date,
-                                                end_date = end_date,
-                                                game_type = [input.type_input()])
-
-        data_list = scrape.get_data(game_list_input = game_list[:])
-        df = (stuff_apply.stuff_apply(fe.feature_engineering(update.update(scrape.get_data_df(data_list = data_list).filter(
-                            (pl.col("pitcher_id") == player_input)&
-                            (pl.col("is_pitch") == True)&
-                            (pl.col('batter_hand').is_in(split_dict_hand[input.split_id()]))
-
-                            )))).with_columns(
-                pl.col('pitch_type').count().over('pitch_type').alias('pitch_count')
-            ))
-        return df
-
-    @render.ui
-    @reactive.event(input.player_button, ignore_none=False)
-    def player_select_ui():
-        # Get the list of pitchers for the selected level and season
-        df_pitcher_info = scrape.get_players(sport_id=int(input.level_input()), season=int(input.year_input()), game_type = [input.type_input()]).filter(
-            pl.col("position").is_in(['P','TWP'])).sort("name")
-        
-        # Create a dictionary of pitcher IDs and names
-        pitcher_dict = dict(zip(df_pitcher_info['player_id'], df_pitcher_info['name']))
-        
-        # Return a select input for choosing a pitcher
-        return ui.input_select("pitcher_id", "Select Pitcher", pitcher_dict, selectize=True)
-
-    @render.ui
-    @reactive.event(input.player_button, ignore_none=False)
-    def date_id():
-        # Create a date range input for selecting the date range within the selected year
-        return ui.input_date_range("date_id", "Select Date Range",
-                                   start=f"{int(input.year_input())}-01-01",
-                                   end=f"{int(input.year_input())}-12-31",
-                                   min=f"{int(input.year_input())}-01-01",
-                                    max=f"{int(input.year_input())}-12-31")
-    @output
-    @render.text
-    def status():
-        # Only show status when generating
-        if input.generate == 0:
-            return ""
-        return ""   
-    
-    @output
-    @render.plot
-    @reactive.event(input.generate_plot, ignore_none=False)   
-    def plot():     
-        # Show progress/loading notification
-        with ui.Progress(min=0, max=1) as p:
-            p.set(message="Generating plot", detail="This may take a while...")
-
-            
-            p.set(0.3, "Gathering data...")
-            year_input = int(input.year_input())
-            sport_id = int(input.level_input())
-            player_input = int(input.pitcher_id())
-            start_date = str(input.date_id()[0])
-            end_date = str(input.date_id()[1])
-
-            print(year_input, sport_id, player_input, start_date, end_date)
-
-            df = cached_data()
-            df = df.clone()
-
-            p.set(0.6, "Creating plot...")
-
-  
-            #plt.rcParams["figure.figsize"] = [10,10]
-            fig = plt.figure(figsize=(26,26))
-            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.GridSpec(6, 8,
-                                height_ratios=[5,20,12,36,36,7],
-                                width_ratios=[4,18,18,18,18,18,18,4])
-
-
-            gs.update(hspace=0.2, wspace=0.5)
-
-            # Define the positions of each subplot in the grid
-            ax_headshot = fig.add_subplot(gs[1,1:3])
-            ax_bio = fig.add_subplot(gs[1,3:5])
-            ax_logo = fig.add_subplot(gs[1,5:7])
-
-            ax_season_table = fig.add_subplot(gs[2,1:7])
-
-            ax_plot_1 = fig.add_subplot(gs[3,1:3])
-            ax_plot_2 = fig.add_subplot(gs[3,3:5])
-            ax_plot_3 = fig.add_subplot(gs[3,5:7])
-
-            ax_table = fig.add_subplot(gs[4,1:7])
-
-            ax_footer = fig.add_subplot(gs[-1,1:7])
-            ax_header = fig.add_subplot(gs[0,1:7])
-            ax_left = fig.add_subplot(gs[:,0])
-            ax_right = fig.add_subplot(gs[:,-1])
-
-            # Hide axes for footer, header, left, and right
-            ax_footer.axis('off')
-            ax_header.axis('off')
-            ax_left.axis('off')
-            ax_right.axis('off')
-
-            sns.set_theme(style="whitegrid", palette=colour_palette)
-            fig.set_facecolor('white')
-
-            df_teams = scrape.get_teams()
-
-            player_headshot(player_input=player_input, ax=ax_headshot,sport_id=sport_id,season=year_input)
-            player_bio(pitcher_id=player_input, ax=ax_bio,sport_id=sport_id,year_input=year_input)
-
-            if input.switch():
-
-                # Get the logo URL from the image dictionary using the team abbreviation
-                logo_url = input.logo_select()
-        
-                # Send a GET request to the logo URL
-                response = requests.get(logo_url)
-        
-                # Open the image from the response content
-                img = Image.open(BytesIO(response.content))
-        
-                # Display the image on the axis
-                ax_logo.set_xlim(0, 1.3)
-                ax_logo.set_ylim(0, 1)
-                ax_logo.imshow(img, extent=[0.3, 1.3, 0, 1], origin='upper')
-        
-                # Turn off the axis
-                ax_logo.axis('off')
-            
-            else:
-                plot_logo(pitcher_id=player_input, ax=ax_logo, df_team=df_teams,df_players=scrape.get_players(sport_id,year_input))
-
-            stat_summary_table(df=df,
-                            ax=ax_season_table,
-                            player_input=player_input,
-                            split=input.split_id(),
-                            sport_id=sport_id,
-                            game_type=[input.type_input()])
-
-            # 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()],[ax_plot_1,ax_plot_2,ax_plot_3],[1,3,5]):
-                if x == 'velocity_kdes':
-                            velocity_kdes(df,
-                            ax=y,
-                            gs=gs,
-                            gs_x=[3,4],
-                            gs_y=[z,z+2],
-                            fig=fig)
-                if x == 'tj_stuff_roling':
-                    tj_stuff_roling(df=df,
-                                window=int(input.rolling_window()),
-                                ax=y)
-                    
-                if x == 'tj_stuff_roling_game':
-                    tj_stuff_roling_game(df=df, 
-                                        window=int(input.rolling_window()),
-                                        ax=y)
-
-                if x == 'break_plot':
-                    break_plot(df = df,ax=y) 
-
-                if x == 'location_plot_lhb':
-                    location_plot(df = df,ax=y,hand='L')
-
-                if x == 'location_plot_rhb':
-                    location_plot(df = df,ax=y,hand='R')
-
-            summary_table(df=df,
-                        ax=ax_table)
-
-            plot_footer(ax_footer)   
-
-            fig.subplots_adjust(left=0.01, right=0.99, top=0.99, bottom=0.01)
-
-
-    
-
-app = App(app_ui, server)
-
-            
-
+import polars as pl
+import api_scraper
+import pandas as pd
+scrape = api_scraper.MLB_Scrape()
+
+import df_update
+update = df_update.df_update()
+from matplotlib.colors import LinearSegmentedColormap, Normalize
+import numpy as np
+import requests
+from io import BytesIO
+from PIL import Image
+from matplotlib.gridspec import GridSpec
+
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+import PIL
+
+level_dict =  {
+               '11':'AAA',
+               '14':'A',}
+
+
+
+def player_bio(pitcher_id: str, ax: plt.Axes, sport_id: int, year_input: int):
+    """
+    Display the player's bio information on the given axis.
+    Parameters
+    ----------
+    pitcher_id : str
+        The player's ID.
+    ax : plt.Axes
+        The axis to display the bio information on.
+    sport_id : int
+        The sport ID (1 for MLB, other for minor leagues).
+    year_input : int
+        The season year.
+    """
+    # Construct the URL to fetch player data
+    url = f"https://statsapi.mlb.com/api/v1/people?personIds={pitcher_id}&hydrate=currentTeam"
+
+    # Send a GET request to the URL and parse the JSON response
+    data = requests.get(url).json()
+
+    # Extract player information from the JSON data
+    player_name = data['people'][0]['fullName']
+    position = data['people'][0]['primaryPosition']['abbreviation']
+    pitcher_hand = data['people'][0]['pitchHand']['code']
+    age = data['people'][0]['currentAge']
+    height = data['people'][0]['height']
+    weight = data['people'][0]['weight']
+
+    # Display the player's name, handedness, age, height, and weight on the axis
+    ax.text(0.5, 1, f'{player_name}', va='top', ha='center', fontsize=30)
+    ax.text(0.5, 0.65, f'{position}, Age:{age}, {height}/{weight}', va='top', ha='center', fontsize=20)
+    ax.text(0.5, 0.4, f'Season Batting Percentiles', va='top', ha='center', fontsize=16)
+
+    # Make API call to retrieve sports information
+    response = requests.get(url='https://statsapi.mlb.com/api/v1/sports').json()
+    
+    # Convert the JSON response into a Polars DataFrame
+    df_sport_id = pl.DataFrame(response['sports'])    
+    abb = df_sport_id.filter(pl.col('id') == sport_id)['abbreviation'][0]
+
+    # Display the season and sport abbreviation
+    ax.text(0.5, 0.20, f'{year_input} {abb} Season', va='top', ha='center', fontsize=14, fontstyle='italic')
+
+    # Turn off the axis
+    ax.axis('off')
+
+
+df_teams = scrape.get_teams()
+team_dict = dict(zip(df_teams['team_id'],df_teams['parent_org_abbreviation']))
+
+
+# List of MLB teams and their corresponding ESPN logo URLs
+mlb_teams = [
+    {"team": "AZ", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/ari.png&h=500&w=500"},
+    {"team": "ATH", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/oak.png&h=500&w=500"},
+    {"team": "ATL", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/atl.png&h=500&w=500"},
+    {"team": "BAL", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/bal.png&h=500&w=500"},
+    {"team": "BOS", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/bos.png&h=500&w=500"},
+    {"team": "CHC", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/chc.png&h=500&w=500"},
+    {"team": "CWS", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/chw.png&h=500&w=500"},
+    {"team": "CIN", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/cin.png&h=500&w=500"},
+    {"team": "CLE", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/cle.png&h=500&w=500"},
+    {"team": "COL", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/col.png&h=500&w=500"},
+    {"team": "DET", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/det.png&h=500&w=500"},
+    {"team": "HOU", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/hou.png&h=500&w=500"},
+    {"team": "KC", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/kc.png&h=500&w=500"},
+    {"team": "LAA", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/laa.png&h=500&w=500"},
+    {"team": "LAD", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/lad.png&h=500&w=500"},
+    {"team": "MIA", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/mia.png&h=500&w=500"},
+    {"team": "MIL", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/mil.png&h=500&w=500"},
+    {"team": "MIN", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/min.png&h=500&w=500"},
+    {"team": "NYM", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/nym.png&h=500&w=500"},
+    {"team": "NYY", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/nyy.png&h=500&w=500"},
+    {"team": "PHI", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/phi.png&h=500&w=500"},
+    {"team": "PIT", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/pit.png&h=500&w=500"},
+    {"team": "SD", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/sd.png&h=500&w=500"},
+    {"team": "SF", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/sf.png&h=500&w=500"},
+    {"team": "SEA", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/sea.png&h=500&w=500"},
+    {"team": "STL", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/stl.png&h=500&w=500"},
+    {"team": "TB", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/tb.png&h=500&w=500"},
+    {"team": "TEX", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/tex.png&h=500&w=500"},
+    {"team": "TOR", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/tor.png&h=500&w=500"},
+    {"team": "WSH", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/mlb/500/scoreboard/wsh.png&h=500&w=500"},
+    {"team": "ZZZ", "logo_url": "https://a.espncdn.com/combiner/i?img=/i/teamlogos/leagues/500/mlb.png&w=500&h=500"}   
+]
+
+df_image = pd.DataFrame(mlb_teams)
+image_dict = df_image.set_index('team')['logo_url'].to_dict()
+image_dict_flip = df_image.set_index('logo_url')['team'].to_dict()
+
+
+merged_dict = {
+    "woba_percent": { "format": '.3f', "percentile_flip": False, "stat_title": "wOBA" },
+    "xwoba_percent": { "format": '.3f', "percentile_flip": False, "stat_title": "xwOBA" },
+    "launch_speed": { "format": '.1f', "percentile_flip": False, "stat_title": "Average EV"},
+    "launch_speed_90": { "format": '.1f', "percentile_flip": False, "stat_title": "90th% EV"},
+    "max_launch_speed": { "format": '.1f', "percentile_flip": False, "stat_title": "Max EV"},
+    "barrel_percent": { "format": '.1%', "percentile_flip": False, "stat_title": "Barrel%" },
+    "hard_hit_percent": { "format": '.1%', "percentile_flip": False, "stat_title": "Hard-Hit%" },
+    "sweet_spot_percent": { "format": '.1%', "percentile_flip": False, "stat_title": "LA Sweet-Spot%" },
+    "zone_percent": { "format": '.1%', "percentile_flip": False, "stat_title": "Zone%" }, 
+    "zone_swing_percent": { "format": '.1%', "percentile_flip": False, "stat_title": "Z-Swing%" },
+    "chase_percent": { "format": '.1%', "percentile_flip": True, "stat_title": "O-Swing%" },
+    "whiff_rate": { "format": '.1%', "percentile_flip": True, "stat_title": "Whiff%" },
+    "k_percent": { "format": '.1%', "percentile_flip": True, "stat_title": "K%" },
+    "bb_percent": { "format": '.1%', "percentile_flip": False, "stat_title": "BB%" },
+    "pull_percent": { "format": '.1%', "percentile_flip": False, "stat_title": "Pull%" },
+    "pulled_fly_ball_percent": { "format": '.1%', "percentile_flip": False, "stat_title": "Pull FB%" },
+}
+
+
+# level_dict =  {'1':'MLB',
+#                '11':'AAA'}
+
+level_dict =  {
+               '11':'AAA',
+               '14':'A (FSL)',}
+
+
+level_dict_file =  {
+               '11':'aaa',
+               '14':'a',}
+
+
+
+year_list = [2024]
+
+
+from shiny import App, reactive, ui, render
+from shiny.ui import h2, tags
+
+# Define the UI layout for the app
+app_ui = ui.page_fluid(
+
+
+    ui.tags.div(
+         {"style": "width:90%;margin: 0 auto;max-width: 1600px;"},
+        ui.tags.style(
+            """
+            h4 {
+                margin-top: 1em;font-size:35px;
+            }
+            h2{
+                font-size:25px;
+            }
+            """
+         ),
+
+    ui.tags.h4("TJStats"),
+    ui.tags.i("Baseball Analytics and Visualizations"),
+    ui.markdown("""<a href='https://x.com/TJStats'>Follow me on Twitter</a><sup>1</sup>"""),
+    ui.markdown("""<a href='https://www.patreon.com/tj_stats'>Support me on Patreon for Access to 2024 Apps</a><sup>1</sup>"""),
+
+    ui.tags.h5("Statcast Batting Summaries"),
+    ui.layout_sidebar(
+        ui.panel_sidebar(
+            # Row for selecting season and level
+            ui.row(
+                ui.column(6, ui.input_select('year_input', 'Select Season', year_list, selected=2024)),
+                ui.column(6, ui.input_select('level_input', 'Select Level', level_dict)),
+            ),
+            # Row for the action button to get player list
+            ui.row(ui.input_action_button("player_button", "Get Player List", class_="btn-primary")),
+            # Row for selecting the player
+            ui.row(ui.column(12, ui.output_ui('player_select_ui', 'Select Player'))),
+
+            ui.row(
+                ui.column(6, ui.input_switch("switch", "Custom Team?", False)),
+                ui.column(6, ui.input_select('logo_select', 'Select Custom Logo', image_dict_flip, multiple=False))
+            ),
+            
+            # Row for the action button to generate plot
+            ui.row(ui.input_action_button("generate_plot", "Generate Plot", class_="btn-primary")),
+            width=3,
+        ),
+                
+        ui.panel_main(
+            ui.navset_tab(
+                # Tab for game summary plot
+                ui.nav("Batter Summary",
+                       ui.output_text("status"),
+                       ui.output_plot('plot', width='1200px', height='1200px')
+                ),
+            )
+        )
+    )
+)
+)
+
+def server(input, output, session):
+    @render.ui
+    @reactive.event(input.player_button, ignore_none=False)
+    def player_select_ui():
+        #Get the list of pitchers for the selected level and season
+        df_pitcher_info = scrape.get_players(sport_id=int(input.level_input()), season=int(input.year_input())).filter(
+            ~pl.col("position").is_in(['P','TWP'])).sort("name")
+        
+        
+
+        # Create a dictionary of pitcher IDs and names
+        batter_dict_pos = dict(zip(df_pitcher_info['player_id'], df_pitcher_info['position']))
+
+        year = int(input.year_input())
+        sport_id = int(input.level_input())
+        batter_summary = pl.read_csv(f'data/statcast/batter_summary_{level_dict_file[str(sport_id)]}_{year}.csv').sort('batter_name',descending=False)
+        # Map elements in Polars DataFrame from a dictionary
+        batter_summary = batter_summary.with_columns(
+            pl.col("batter_id").map_elements(lambda x: batter_dict_pos.get(x, x)).alias("position")
+        )
+
+
+        batter_dict_pos = dict(zip(batter_summary['batter_id'], batter_summary['batter_name']))
+        # Create a dictionary of pitcher IDs and names
+        batter_dict = dict(zip(batter_summary['batter_id'], batter_summary['batter_name'] + ' - ' + batter_summary['position']))
+        
+        # Return a select input for choosing a pitcher
+        return ui.input_select("batter_id", "Select Batter", batter_dict, selectize=True)
+    
+
+
+    
+    @output
+    @render.plot
+    @reactive.event(input.generate_plot, ignore_none=False)   
+    def plot():     
+        # Show progress/loading notification
+        with ui.Progress(min=0, max=1) as p:
+
+            def draw_baseball_savant_percentiles(new_player_metrics, new_player_percentiles, colors=None,
+                                                                                sport_id=None,
+                                            year_input=None):
+                """
+                Draw Baseball Savant-style percentile bars with proper alignment and scaling.
+
+                :param new_player_metrics: DataFrame containing new player metrics.
+                :param new_player_percentiles: DataFrame containing new player percentiles.
+                :param colors: List of colors for bars (optional, red/blue default).
+                """
+                # Extract player information
+                batter_id = new_player_metrics['batter_id'][0]
+                player_name = batter_name_id[batter_id]
+                stats = [merged_dict[x]['stat_title'] for x in merged_dict.keys()]
+
+                # Calculate percentiles and values
+                percentiles = [int((1 - x) * 100) if merged_dict[stat]["percentile_flip"] else int(x * 100) for x, stat in zip(new_player_percentiles.select(merged_dict.keys()).to_numpy()[0], merged_dict.keys())]
+                percentiles = np.clip(percentiles, 1, 100)
+                values = [str(f'{x:{merged_dict[stat]["format"]}}').strip('%') for x, stat in zip(new_player_metrics.select(merged_dict.keys()).to_numpy()[0], merged_dict.keys())]
+
+                # Get team logo URL
+                logo_url = image_dict[team_dict[player_team_dict[batter_id]]]
+
+                # Create a custom colormap
+                color_list = ['#3661AD', '#B4CFD1', '#D82129']
+                cmap = LinearSegmentedColormap.from_list("custom_cmap", color_list)
+                norm = Normalize(vmin=0.1, vmax=0.9)
+                norm_percentiles = norm(percentiles / 100)
+                colors = [cmap(p) for p in norm_percentiles]
+
+                # Figure setup
+                num_stats = len(stats)
+                bar_height = 4.5
+                spacing = 1
+                fig_height = (bar_height + spacing) * num_stats
+                fig = plt.figure(figsize=(12, 12))
+                gs = GridSpec(6, 5, height_ratios=[0.1, 1.5, 0.9, 0.9, 7.6, 0.1], width_ratios=[0.2, 1.5, 7, 1.5, 0.2])
+
+                # Define subplots
+                ax_title = fig.add_subplot(gs[1, 2])
+                ax_table = fig.add_subplot(gs[2, :])
+                ax_fv_table = fig.add_subplot(gs[3, :])
+                ax = fig.add_subplot(gs[4, :])
+                ax_logo = fig.add_subplot(gs[1, 3])
+
+                ax.set_xlim(-1, 99)
+                ax.set_ylim(-1, 99)
+                ax.set_aspect("equal")
+                ax.axis("off")
+
+                # Draw each bar
+                for i, (stat, percentile, value, color) in enumerate(zip(stats, percentiles, values, colors)):
+                    y = fig_height - (i + 1) * (bar_height + spacing)
+                    ax.add_patch(patches.Rectangle((0, y + bar_height / 4), 100, bar_height / 2, color="#C7DCDC", lw=0))
+                    ax.add_patch(patches.Rectangle((0, y), percentile, bar_height, color=color, lw=0))
+                    circle_y = y + bar_height - bar_height / 2
+                    circle = plt.Circle((percentile, circle_y), bar_height / 2, color=color, ec='white', lw=1.5, zorder=10)
+                    ax.add_patch(circle)
+                    fs = 14
+                    ax.text(percentile, circle_y, f"{percentile}", ha="center", va="center", fontsize=10, color='white', zorder=10, fontweight='bold')
+                    ax.text(-5, y + bar_height / 2, stat, ha="right", va="center", fontsize=fs)
+                    ax.text(115, y + bar_height / 2, str(value), ha="right", va="center", fontsize=fs, zorder=5)
+                    if i < len(stats) and i > 0:
+                        ax.hlines(y=y + bar_height + spacing / 2, color='#399098', linestyle=(0, (5, 5)), linewidth=1, xmin=-33, xmax=0)
+                        ax.hlines(y=y + bar_height + spacing / 2, color='#399098', linestyle=(0, (5, 5)), linewidth=1, xmin=100, xmax=115)
+
+                # Draw vertical lines for 10%, 50%, and 90% with labels
+                for x, label, align, color in zip([10, 50, 90], ["Poor", "Average", "Great"], ['center', 'center', 'center'], color_list):
+                    ax.axvline(x=x, ymin=0, ymax=1, color='#FFF', linestyle='-', lw=1, zorder=1, alpha=0.5)
+                    ax.text(x, fig_height + 4, label, ha=align, va='center', fontsize=12, fontweight='bold', color=color)
+                    triangle = patches.RegularPolygon((x, fig_height + 1), 3, radius=1, orientation=0, color=color, zorder=2)
+                    ax.add_patch(triangle)
+
+                # # Title
+                # ax_title.set_ylim(0, 1)
+                # ax_title.text(0.5, 0.5, f"{player_name} - {player_position_dict[batter_id]}\nPercentile Rankings - 2024 AAA", ha="center", va="center", fontsize=24)
+                # ax_title.axis("off")
+                player_bio(batter_id, ax=ax_title, sport_id=sport_id, year_input=year_input)
+
+                # Add team logo
+                #response = requests.get(logo_url)
+                if input.switch():
+                    response = requests.get(input.logo_select())
+                else:
+                    response = requests.get(logo_url)
+                img = Image.open(BytesIO(response.content))
+                ax_logo.imshow(img)
+                ax_logo.axis("off")
+                ax.axis('equal')
+
+                # Metrics data table
+                metrics_data = {
+                    "Pitches": new_player_metrics['pitches'][0],
+                    "PA": new_player_metrics['pa'][0],
+                    "BIP": new_player_metrics['bip'][0],
+                    "HR": f"{new_player_metrics['home_run'][0]:.0f}",
+                    "AVG": f"{new_player_metrics['avg'][0]:.3f}",
+                    "OBP": f"{new_player_metrics['obp'][0]:.3f}",
+                    "SLG": f"{new_player_metrics['slg'][0]:.3f}",
+                    "OPS": f"{new_player_metrics['obp'][0] + new_player_metrics['slg'][0]:.3f}",
+                }
+                df_table = pd.DataFrame(metrics_data, index=[0])
+                ax_table.axis('off')
+                table = ax_table.table(cellText=df_table.values, colLabels=df_table.columns, cellLoc='center', loc='bottom', bbox=[0.07, 0, 0.86, 1])
+                for key, cell in table.get_celld().items():
+                    if key[0] == 0:
+                        cell.set_text_props(fontweight='bold')
+                table.auto_set_font_size(False)
+                table.set_fontsize(12)
+                table.scale(1, 1.5)
+
+                # Additional subplots for spacing
+                ax_top = fig.add_subplot(gs[0, :])
+                ax_bot = fig.add_subplot(gs[-1, :])
+                ax_top.axis('off')
+                ax_bot.axis('off')
+                ax_bot.text(0.05, 2, "By: Thomas Nestico (@TJStats)", ha="left", va="center", fontsize=14)
+                ax_bot.text(0.95, 2, "Data: MLB, Fangraphs", ha="right", va="center", fontsize=14)
+                fig.subplots_adjust(left=0.01, right=0.99, top=0.99, bottom=0.01)
+
+                # Player headshot
+                ax_headshot = fig.add_subplot(gs[1, 1])
+                try:
+                    url = f'https://img.mlbstatic.com/mlb-photos/image/upload/c_fill,g_auto/w_640/v1/people/{batter_id}/headshot/milb/current.png'
+                    response = requests.get(url)
+                    img = Image.open(BytesIO(response.content))
+                    ax_headshot.set_xlim(0, 1)
+                    ax_headshot.set_ylim(0, 1)
+                    ax_headshot.imshow(img, extent=[1/6, 5/6, 0, 1], origin='upper')
+                except PIL.UnidentifiedImageError:
+                    ax_headshot.axis('off')
+                    return
+                ax_headshot.axis('off')
+                ax_table.set_title('Season Summary', style='italic')
+
+                # Fangraphs scouting grades table
+                print(batter_id)
+                ax_fv_table.axis('off')
+                if batter_id not in dict_mlb_fg.keys():
+                    ax_fv_table.text(x=0.5, y=0.5, s='No Scouting Data', style='italic', ha='center', va='center', fontsize=20, bbox=dict(facecolor='white', alpha=1, pad=10))
+                    return
+                df_fv_table = df_prospects[(df_prospects['minorMasterId'] == dict_mlb_fg[batter_id])][['cFV', 'Hit', 'Game', 'Raw', 'Spd', 'Fld']].reset_index(drop=True)
+                ax_fv_table.axis('off')
+                if df_fv_table.empty:
+                    ax_fv_table.text(x=0.5, y=0.5, s='No Scouting Data', style='italic', ha='center', va='center', fontsize=20, bbox=dict(facecolor='white', alpha=1, pad=10))
+                    return
+                df_fv_table.columns = ['FV', 'Hit', 'Game', 'Raw', 'Spd', 'Fld']
+                table_fv = ax_fv_table.table(cellText=df_fv_table.values, colLabels=df_fv_table.columns, cellLoc='center', loc='bottom', bbox=[0.07, 0, 0.86, 1])
+                for key, cell in table_fv.get_celld().items():
+                    if key[0] == 0:
+                        cell.set_text_props(fontweight='bold')
+                table_fv.auto_set_font_size(False)
+                table_fv.set_fontsize(12)
+                table_fv.scale(1, 1.5)
+                ax_fv_table.set_title('Fangraphs Scouting Grades', style='italic')
+
+
+
+                #plt.show()
+
+
+            def calculate_new_player_percentiles(player_id, new_player_metrics, player_summary_filtered):
+                """
+                Calculate percentiles for a new player's metrics.
+
+                :param player_id: ID of the player.
+                :param new_player_metrics: DataFrame containing new player metrics.
+                :param player_summary_filtered: Filtered player summary DataFrame.
+                :return: DataFrame containing new player percentiles.
+                """
+                filtered_summary_clone = player_summary_filtered[['batter_id'] + stat_list].filter(pl.col('batter_id') != player_id).clone()
+                combined_data = pl.concat([filtered_summary_clone, new_player_metrics], how="vertical").to_pandas()
+                combined_percentiles = pl.DataFrame(pd.concat([combined_data['batter_id'], combined_data[stat_list].rank(pct=True)], axis=1))
+                new_player_percentiles = combined_percentiles.filter(pl.col('batter_id') == player_id)
+                return new_player_percentiles
+ 
+ 
+ 
+            p.set(message="Generating plot", detail="This may take a while...")
+
+            
+            p.set(0.3, "Gathering data...")
+
+            # Example: New player's metrics
+            year = int(input.year_input())
+            sport_id = int(input.level_input())
+            batter_id = int(input.batter_id())
+
+
+            df_player = scrape.get_players(sport_id=sport_id,season=year)
+            batter_name_id = dict(zip(df_player['player_id'],df_player['name']))
+            player_team_dict = dict(zip(df_player['player_id'],df_player['team']))
+            player_position_dict = dict(zip(df_player['player_id'],df_player['position']))
+
+
+            batter_summary = pl.read_csv(f'data/statcast/batter_summary_{level_dict_file[str(sport_id)]}_{year}.csv')
+            df_prospects = pd.read_csv(f'data/prospects/prospects_{year}.csv')
+            df_rosters = pd.read_csv(f'data/rosters/fangraphs_rosters_{year}.csv')
+            df_small = df_rosters[['minorbamid','minormasterid']].dropna()
+            dict_mlb_fg=dict(zip(df_small['minorbamid'].astype(int),df_small['minormasterid']))
+
+
+
+
+            batter_summary_filter = batter_summary.filter((pl.col('pa') >= 300) & (pl.col('launch_speed') >= 0))
+            stat_list = batter_summary.columns[2:]
+            batter_summary_filter_pd = batter_summary_filter.to_pandas()
+            new_player_metrics = batter_summary.filter(pl.col('batter_id') == batter_id)[['batter_id'] + stat_list]
+
+            # Get percentiles for the new player
+            new_player_percentiles = calculate_new_player_percentiles(batter_id, new_player_metrics, batter_summary_filter)
+
+            p.set(0.6, "Creating plot...")
+            # Draw Baseball Savant-style percentile bars
+            draw_baseball_savant_percentiles(new_player_metrics=new_player_metrics, 
+                                            new_player_percentiles=new_player_percentiles,
+                                            sport_id=sport_id,
+                                            year_input=year)
+
 app = App(app_ui, server)