Upload 2 files

api_scraper.py

@@ -101,24 +101,32 @@ class MLB_Scrape:
         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]
+            game_list = [item for sublist in [[y['gamePk'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+            time_list = [item for sublist in [[y['gameDate'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+            date_list = [item for sublist in [[y['officialDate'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+            away_team_list = [item for sublist in [[y['teams']['away']['team']['name'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+            away_team_id_list = [item for sublist in [[y['teams']['away']['team']['id'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+            home_team_list = [item for sublist in [[y['teams']['home']['team']['name'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+            home_team_id_list = [item for sublist in [[y['teams']['home']['team']['id'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+            state_list = [item for sublist in [[y['status']['codedGameState'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+            venue_id = [item for sublist in [[y['venue']['id'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+            venue_name = [item for sublist in [[y['venue']['name'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+            gameday_type = [item for sublist in [[y['gamedayType'] for y in x['games']] for x in game_call['dates']] for item in sublist]
+            # Create a Polars DataFrame with the extracted data
+
 
             # 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,
+                                        'away_id': away_team_id_list,
                                         'home': home_team_list,
+                                        'home_id': home_team_id_list,
                                         'state': state_list,
                                         'venue_id': venue_id,
-                                        'venue_name': venue_name})
+                                        'venue_name': venue_name,
+                                        'gameday_type':gameday_type})
 
         
             # Check if the DataFrame is empty

app.py

@@ -1,153 +1,830 @@
-import polars as pl
-import numpy as np
-import joblib
-from shiny import App, reactive, render, ui
-import matplotlib.pyplot as plt
-import matplotlib.ticker as tkr
-import seaborn as sns
-import adjustText
-sns.set_style('whitegrid')
-
-
-import matplotlib
-cmap_sum = matplotlib.colors.LinearSegmentedColormap.from_list("", ['#FFFFFF','#FFB000','#FE6100'])
-
-xwoba_model = joblib.load('joblib_model/xwoba_model.joblib')
-
-x = np.arange(-30,90.5,.5)
-y = np.arange(0,120.5,0.1)
-
-xx, yy = np.meshgrid(x, y)
-
-df = pl.DataFrame({'launch_angle': xx.ravel(), 'launch_speed': yy.ravel()})
-
-df = df.with_columns(
-    pl.Series('xwoba', xwoba_model.predict_proba(df.select(['launch_angle','launch_speed'])) @ [0, 0.883, 1.244, 1.569, 2.004])
-)
-
-df = df.with_columns(
-    pl.Series('xslg', xwoba_model.predict_proba(df.select(['launch_angle','launch_speed'])) @ [0, 1, 2, 3, 4])
-)
-
-app_ui = ui.page_sidebar(
-    ui.sidebar(
-        ui.markdown("""
-        ### How to use this app
-        
-        1. Click anywhere on the plot to select a point, or manually enter coordinates
-        2. The selected point's coordinates will update automatically
-        3. The xwOBA value will be calculated based on these coordinates
-        """),
-        ui.hr(),
-        ui.input_numeric("x_select", "Launch Speed (mph)", value=110),
-        ui.input_numeric("y_select", "Launch Angle (°)", value=30),
-        ui.input_switch("flip_stat", "xwOBA", value=False),
-
-
-    ),
-    ui.output_plot("plot",width='900px',height='900px', click=True)
-)
-
-
-def server(input, output, session):
-    # Store the coordinates in reactive values
-    x_coord = reactive.value(110)
-    y_coord = reactive.value(30)
-    
-    @reactive.effect
-    @reactive.event(input.plot_click)
-    def _():
-        # Update reactive values when plot is clicked
-        click_data = input.plot_click()
-        if click_data is not None:
-            x_coord.set(click_data["x"])
-            y_coord.set(click_data["y"])
-            # Update the numeric inputs
-            ui.update_numeric("x_select", value=round(click_data["x"],1))
-            ui.update_numeric("y_select", value=round(click_data["y"],1))
-    
-    @reactive.effect
-    @reactive.event(input.x_select, input.y_select)
-    def _():
-        # Update reactive values when numeric inputs change
-        x_coord.set(round(input.x_select(),1))
-        y_coord.set(round(input.y_select(),1))
-
-
-    @render.plot
-    def plot():
-        switch = input.flip_stat()
-        fig, ax = plt.subplots(1, 1, figsize=(9, 9))
-
-
-        if switch:
-            h = ax.hexbin(df['launch_speed'], 
-                        df['launch_angle'],
-                        C=df['xwoba'], 
-                        gridsize=(40,25), 
-                        cmap=cmap_sum,
-                        vmin=0.0,
-                        vmax=2.0,)
-            bounds=[0.0,0.4,0.8,1.2,1.6,2.0]
-            fig.colorbar(h, ax=ax, label='xwOBA',format=tkr.FormatStrFormatter('%.3f'),shrink=0.5,
-                        ticks=bounds)
-            
-        else:
-            h = ax.hexbin(df['launch_speed'], 
-                        df['launch_angle'],
-                        C=df['xslg'], 
-                        gridsize=(40,25), 
-                        cmap=cmap_sum,
-                        vmin=0.0,
-                        vmax=4.0,)
-            bounds=[0.0,0.5,1,1.5,2,2.5,3,3.5,4]
-            fig.colorbar(h, ax=ax, label='xSLG',format=tkr.FormatStrFormatter('%.3f'),shrink=0.5,
-                        ticks=bounds)
-
-
-
-        ax.set_xlabel('Launch Speed')
-        ax.set_ylabel('Launch Angle')
-        if switch:
-            ax.set_title('Exit Velocity vs Launch Angle\nExpected Weighted On Base Average (xwOBA)\nBy: @TJStats, Data:MLB')
-        else:
-            ax.set_title('Exit Velocity vs Launch Angle\nExpected Total Bases (xSLG)\nBy: @TJStats, Data:MLB')
-            
-        ax.grid(False)
-        ax.axis('square')
-        ax.set_xlim(0, 120)
-        ax.set_ylim(-30, 90)
-
-        x_select = input.x_select()
-        y_select = input.y_select()
-
-
-        sns.scatterplot(x=[x_select],y=[y_select],color='#648FFF',s=50,ax=ax,edgecolor='k',zorder=100)
-
-        
-        if switch:
-            xwoba_value = (xwoba_model.predict_proba([[y_select,x_select]]) @ [0, 0.883, 1.244, 1.569, 2.004])[0]
-            texts = [ax.text(x_select+3, y_select+3, f'xwOBA: {xwoba_value:.3f}', color='black', fontsize=12, weight='bold',
-                            zorder=1000, bbox=dict(facecolor='white', alpha=0.5, edgecolor='black'))]
-    
-        else:
-            xwoba_value = (xwoba_model.predict_proba([[y_select,x_select]]) @ [0, 1, 2, 3, 4])[0]
-            texts = [ax.text(x_select+3, y_select+3, f'xSLG: {xwoba_value:.3f}', color='black', fontsize=12, weight='bold',
-                            zorder=1000, bbox=dict(facecolor='white', alpha=0.5, edgecolor='black'))]
-    
-
-
-
-        adjustText.adjust_text(texts,
-
-                                arrowprops=dict(arrowstyle='->', color='#DC267F'),avoid_self=True,
-                                min_arrow_len =5)
-        # xwoba_value = 
-
-        ax.axhline(y=y_select, color='k', linestyle='--',linewidth=1,alpha=0.5)
-        ax.axvline(x=x_select, color='k', linestyle='--',linewidth=1,alpha=0.5)
-
-        # ax.axis('square')
-
-
-app = App(app_ui, server)
+#import packages
+import pandas as pd
+import json
+import numpy as np
+import requests
+pd.options.mode.chained_assignment = None
+from datetime import datetime
+import time
+import difflib 
+from datetime import datetime, timedelta
+import api_scraper
+import polars as pl
+import matplotlib.colors
+import matplotlib.colors as mcolors
+from shiny import App, ui, render, reactive
+
+def add_empty_rows(df, n_empty, period):
+    """ adds 'n_empty' empty rows every 'period' rows  to 'df'.
+        Returns a new DataFrame. """
+
+    # to make sure that the DataFrame index is a RangeIndex(start=0, stop=len(df))
+    # and that the original df object is not mutated.
+    df = df.reset_index(drop=True)
+
+    # length of the new DataFrame containing the NaN rows
+    len_new_index = len(df) + n_empty*(len(df) // period)
+    # index of the new DataFrame
+    new_index = pd.RangeIndex(len_new_index)
+
+    # add an offset (= number of NaN rows up to that row)
+    # to the current df.index to align with new_index.
+    df.index += n_empty * (df.index
+                             .to_series()
+                             .groupby(df.index // period)
+                             .ngroup())
+
+    # reindex by aligning df.index with new_index.
+    # Values of new_index not present in df.index are filled with NaN.
+    new_df = df.reindex(new_index)
+
+    return new_df
+
+unique_team_list = [120,
+                    141,
+                    140,
+                    139,
+                    138,
+                    137,
+                    136,
+                    135,
+                    134,
+                    143,
+                    133,
+                    147,
+                    121,
+                    142,
+                    158,
+                    146,
+                    119,
+                    108,
+                    118,
+                    117,
+                    116,
+                    145,
+                    115,
+                    114,
+                    113,
+                    112,
+                    111,
+                    110,
+                    109,
+                    144]
+
+## Create a dataframe of teams to assist with selecting a player to search
+#specifically for the case where multiple players share the same name
+#Make an api call to get a dictionary of all teams
+teams =  requests.get(url='https://statsapi.mlb.com/api/v1/teams/').json()
+#Select only teams that are at the MLB level
+mlb_teams_city = [x['franchiseName'] for x in teams['teams'] if x['sport']['name'] == 'Major League Baseball']
+mlb_teams_name = [x['teamName'] for x in teams['teams'] if x['sport']['name'] == 'Major League Baseball']
+mlb_teams_franchise = [x['name'] for x in teams['teams'] if x['sport']['name'] == 'Major League Baseball']
+mlb_teams_id = [x['id'] for x in teams['teams'] if x['sport']['name'] == 'Major League Baseball']
+mlb_teams_abb = [x['abbreviation'] for x in teams['teams'] if x['sport']['name'] == 'Major League Baseball']
+
+#Create a dataframe of all the teams
+mlb_teams_df = pd.DataFrame(data={'team_id':mlb_teams_id,'city':mlb_teams_franchise,'name':mlb_teams_name,'franchise':mlb_teams_franchise,'abbreviation':mlb_teams_abb})
+##Create a dataframe of all players in the database
+#Make an api call to get a dictionary of all players
+player_data = requests.get(url='https://statsapi.mlb.com/api/v1/sports/11/players').json()
+
+#Select relevant data that will help distinguish players from one another
+fullName_list = [x['fullName'] for x in player_data['people']]
+id_list = [x['id'] for x in player_data['people']]
+position_list = [x['primaryPosition']['abbreviation'] for x in player_data['people']]
+team_list = [x['currentTeam']['id']for x in player_data['people']]
+
+#Create a dataframe of players and their current team ids
+player_df_all = pd.DataFrame(data={'id':id_list,'name':fullName_list,'position':position_list,'team_id':team_list})
+#Use the teams dataframe to merge the team name to the players dataframe
+player_df_all = player_df_all.merge(right=mlb_teams_df[['team_id','franchise']],left_on='team_id',right_on='team_id',how='left',suffixes=['','_y'])
+#drop the duplicated id column
+player_df_all = player_df_all.drop(columns=['team_id'])
+#make a column of the names all uppercase to make lookups easier
+player_df_all['upper_name'] = player_df_all['name'].str.upper()
+#rename to make the data clearer
+player_df_all = player_df_all.rename(columns={'franchise':'currentTeam'})
+
+
+
+import matplotlib.pyplot as plt
+colour_palette = ['#FFB000','#648FFF','#785EF0',
+                  '#DC267F','#FE6100','#3D1EB2','#894D80','#16AA02','#B5592B','#A3C1ED']
+
+cmap_up = mcolors.LinearSegmentedColormap.from_list("", ['#FFFFFF', '#FFB000'])
+   
+
+# Function to alternate row colors
+def highlight_alternate_rows(x):
+    return ['background-color: #ebebeb' if i % 2 == 0 else '' for i in range(len(x))]
+# Function to apply thick border to data cells
+# Columns after which we want a thick vertical line
+
+scraper = api_scraper.MLB_Scrape()
+df_teams = scraper.get_teams()
+
+teams_mlb = df_teams.filter(pl.col("league_id").is_in([103,104])).sort("abbreviation")
+teams_dict = dict(zip(teams_mlb['team_id'],teams_mlb['abbreviation']))
+
+teams_name_dict = dict(zip(teams_mlb['team_id'],teams_mlb['franchise']))
+
+{109: 'Arizona Diamondbacks',
+ 144: 'Atlanta Braves',
+ 110: 'Baltimore Orioles',
+ 111: 'Boston Red Sox',
+ 112: 'Chicago Cubs',
+ 145: 'Chicago White Sox',
+ 113: 'Cincinnati Reds',
+ 114: 'Cleveland Guardians',
+ 115: 'Colorado Rockies',
+ 116: 'Detroit Tigers',
+ 117: 'Houston Astros',
+ 118: 'Kansas City Royals',
+ 108: 'Los Angeles Angels',
+ 119: 'Los Angeles Dodgers',
+ 146: 'Miami Marlins',
+ 158: 'Milwaukee Brewers',
+ 142: 'Minnesota Twins',
+ 121: 'New York Mets',
+ 147: 'New York Yankees',
+ #133: 'Athletics',
+ 133: 'Oakland Athletics',
+ 143: 'Philadelphia Phillies',
+ 134: 'Pittsburgh Pirates',
+ 135: 'San Diego Padres',
+ 137: 'San Francisco Giants',
+ 136: 'Seattle Mariners',
+ 138: 'St. Louis Cardinals',
+ 139: 'Tampa Bay Rays',
+ 140: 'Texas Rangers',
+ 141: 'Toronto Blue Jays',
+ 120: 'Washington Nationals'}
+
+
+data_r_1 = requests.get("https://pub-api-ro.fantasysports.yahoo.com/fantasy/v2/league/458.l.1423;out=settings/players;position=ALL;start=0;count=5000;sort=rank_season;search=;out=percent_owned;out=auction_values,ranks;ranks=season;ranks_by_position=season;out=expert_ranks;expert_ranks.rank_type=projected_season_remaining/draft_analysis;cut_types=diamond;slices=last7days?format=json_f").json()
+#data_r_2 = requests.get("https://pub-api-ro.fantasysports.yahoo.com/fantasy/v2/league/422.l.1416;out=settings/players;position=ALL;start=758;count=5000;sort=rank_season;search=;out=auction_values,ranks;ranks=season;ranks_by_position=season;out=expert_ranks;expert_ranks.rank_type=projected_season_remaining/draft_analysis;cut_types=diamond;slices=last7days?format=json_f").json()
+# 757 is bad
+#https://pub-api-ro.fantasysports.yahoo.com/fantasy/v2/league/422.l.1416;out=settings/players;position=ALL;start=0;count=756;sort=rank_season;search=;out=auction_values,ranks;ranks=season;ranks_by_position=season;out=expert_ranks;expert_ranks.rank_type=projected_season_remaining/draft_analysis;cut_types=diamond;slices=last7days?format=json_f
+
+total_list = []
+
+for x in data_r_1['fantasy_content']['league']['players']:
+    single_list = []
+
+    single_list.append((x['player']['player_id']))
+    single_list.append(x['player']['name']['full'])
+    single_list.append(x['player']['name']['first'])
+    single_list.append(x['player']['name']['last'])
+    single_list.append(x['player']['draft_analysis']['average_pick'])
+    single_list.append(x['player']['average_auction_cost'])
+    single_list.append(x['player']['display_position'])
+    single_list.append(x['player']['editorial_team_abbr'])
+    total_list.append(single_list)
+
+df_2023 = pd.DataFrame(data=total_list, columns=['player_id','full','first','last','average_pick', 'average_cost','display_position','editorial_team_abbr'])
+
+ 
+team_abb_list = ['ATL', 'AZ', 'BAL', 'BOS', 'CHC', 'CIN', 'CLE', 'COL', 'CWS',
+      'DET', 'HOU', 'KC', 'LAA', 'LAD', 'MIA', 'MIL', 'MIN', 'NYM',
+      'NYY', 'ATH', 'PHI', 'PIT', 'SD', 'SEA', 'SF', 'STL', 'TB', 'TEX',
+      'TOR', 'WSH']
+
+team_abb_list_yahoo = ['ATL', 'ARI', 'BAL', 'BOS', 'CHC', 'CIN', 'CLE', 'COL', 'CWS',
+      'DET', 'HOU', 'KC', 'LAA', 'LAD', 'MIA', 'MIL', 'MIN', 'NYM',
+      'NYY', 'ATH', 'PHI', 'PIT', 'SD', 'SEA', 'SF', 'STL', 'TB', 'TEX',
+      'TOR', 'WSH']
+team_abb_df = pd.DataFrame({'mlb_team':team_abb_list,'yahoo_team':team_abb_list_yahoo})
+
+
+
+from shiny import App, ui, render
+import pandas as pd
+
+# Create sample data for the tables
+data1 = pd.DataFrame({
+    'Name': ['Alice', 'Bob', 'Charlie'],
+    'Age': [25, 30, 35],
+    'City': ['New York', 'London', 'Paris']
+})
+
+data2 = pd.DataFrame({
+    'Product': ['Laptop', 'Phone', 'Tablet'],
+    'Price': [1200, 800, 500],
+    'Stock': [50, 100, 75]
+})
+
+data3 = pd.DataFrame({
+    'Country': ['USA', 'UK', 'France'],
+    'Population': ['331M', '67M', '67M'],
+    'Language': ['English', 'English', 'French']
+})
+
+app_ui = ui.page_sidebar(
+    ui.sidebar(
+        ui.input_select(
+            "team_id",
+            "Select Team",
+            choices=teams_dict
+        ),
+        # ui.h3("Sidebar"),
+        # ui.p("This is a demonstration of a card with tabs containing tables.")
+    ),
+    ui.card(
+        ui.output_text("selected_team_info"),
+        ui.navset_card_tab(
+            ui.nav_panel(
+                "Lineups",
+                ui.div({"style": "font-size:1.7em;"}, ui.output_text("lineup_title")),
+                ui.output_table("table1")
+            ),
+            ui.nav_panel(
+                "Summary",
+                ui.div({"style": "font-size:1.7em;"}, ui.output_text("summary_title")),
+                ui.output_table("table2")
+            ),
+            ui.nav_panel(
+                "Fantasy Eligibility",
+                ui.div({"style": "font-size:1.7em;"}, ui.output_text("fantasy_title")),
+                ui.output_table("table3")
+            )
+        )
+    )
+)
+
+def server(input, output, session):
+
+    @render.text
+    def lineup_title():
+
+            return f"{teams_name_dict[int(input.team_id())]} Spring Training Lineups"
+
+    @render.text
+    def summary_title():
+
+            return f"{teams_name_dict[int(input.team_id())]} Spring Training Lineup Summary"
+
+    @render.text
+    def fantasy_title():
+
+            return f"{teams_name_dict[int(input.team_id())]} Spring Training Position Eligibility Tracker - Yahoo"
+
+
+    @reactive.calc
+    def cached_data():
+        team_id_select = int(input.team_id())
+
+        df_schedule = scraper.get_schedule(year_input=[2025],sport_id=[1],game_type=['S','E'])
+            
+        # df_schedule_p = scraper.get_schedule(year_input=[2024],sport_id=[21],game_type=['E'])
+
+        # df_schedule_all = pl.concat([df_schedule,df_schedule_p])
+
+        df_schedule_all = pl.concat([df_schedule])
+
+
+        df_schedule_team = df_schedule_all.filter((pl.col('date') <= datetime.today().date())&((pl.col('home_id') == team_id_select)|(pl.col('away_id') == team_id_select)))
+        if df_schedule_team.is_empty():
+            return None, None, None
+        statcast_dict = dict(zip(df_schedule_team['game_id'],df_schedule_team['gameday_type']))
+        game_list = df_schedule_team['game_id'][:]
+        game_data = scraper.get_data(game_list)
+
+        print('Importing New Games.')
+        lineup_data = []
+        game_id = []
+        date = []
+        player_id = []
+        player_name = []
+        position = []
+        team_id = []
+        batting_order = []
+        handedness_batter = []
+        away_home = []
+        handedness_pitcher = []
+        pitcher_name = []
+        for y in range(0,len(game_data)):
+            game_id.append(len([x if 'battingOrder' in game_data[y]['liveData']['boxscore']['teams']['away']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['away']['players']])*[game_data[y]['gameData']['game']['pk']])
+            date.append(len([x if 'battingOrder' in game_data[y]['liveData']['boxscore']['teams']['away']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['away']['players']])*[game_data[y]['gameData']['datetime']['officialDate']])
+            player_id.append([x if 'battingOrder' in game_data[y]['liveData']['boxscore']['teams']['away']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['away']['players']])
+            player_name.append([game_data[y]['liveData']['boxscore']['teams']['away']['players'][x]['person']['fullName'] if 'battingOrder' in game_data[y]['liveData']['boxscore']['teams']['away']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['away']['players']])
+            position.append([game_data[y]['liveData']['boxscore']['teams']['away']['players'][x]['allPositions'][0]['code'] if 'battingOrder' in game_data[y]['liveData']['boxscore']['teams']['away']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['away']['players']])
+            team_id.append([game_data[y]['liveData']['boxscore']['teams']['away']['players'][x]['parentTeamId'] if 'parentTeamId' in game_data[y]['liveData']['boxscore']['teams']['away']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['away']['players']])
+            batting_order.append([game_data[y]['liveData']['boxscore']['teams']['away']['players'][x]['battingOrder'] if 'battingOrder' in game_data[y]['liveData']['boxscore']['teams']['away']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['away']['players']])
+            away_home.append(['away' if 'battingOrder' in game_data[y]['liveData']['boxscore']['teams']['away']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['away']['players']])
+            handedness_batter.append([game_data[y]['gameData']['players'][x]['batSide']['code'] if 'battingOrder' in game_data[y]['liveData']['boxscore']['teams']['away']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['away']['players']])
+            handedness_pitcher.append([game_data[y]['gameData']['players']['ID'+str(game_data[y]['gameData']['probablePitchers']['home']['id'])]['pitchHand']['code']+'HP' if 'home' in game_data[y]['gameData']['probablePitchers'] else None for x in game_data[y]['liveData']['boxscore']['teams']['away']['players']])
+            pitcher_name.append([game_data[y]['gameData']['players']['ID'+str(game_data[y]['gameData']['probablePitchers']['home']['id'])]['fullName'] if 'home' in game_data[y]['gameData']['probablePitchers'] else None for x in game_data[y]['liveData']['boxscore']['teams']['away']['players']])
+            
+            game_id.append(len([x if 'battingOrder' in game_data[y]['liveData']['boxscore']['teams']['home']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['home']['players']])*[game_data[y]['gameData']['game']['pk']])
+            date.append(len([x if 'battingOrder' in game_data[y]['liveData']['boxscore']['teams']['home']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['home']['players']])*[game_data[y]['gameData']['datetime']['officialDate']])
+            player_id.append([x if 'battingOrder' in game_data[y]['liveData']['boxscore']['teams']['home']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['home']['players']])
+            player_name.append([game_data[y]['liveData']['boxscore']['teams']['home']['players'][x]['person']['fullName'] if 'battingOrder' in game_data[y]['liveData']['boxscore']['teams']['home']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['home']['players']])
+            position.append([game_data[y]['liveData']['boxscore']['teams']['home']['players'][x]['allPositions'][0]['code'] if 'battingOrder' in game_data[y]['liveData']['boxscore']['teams']['home']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['home']['players']])
+            team_id.append([game_data[y]['liveData']['boxscore']['teams']['home']['players'][x]['parentTeamId'] if 'parentTeamId' in game_data[y]['liveData']['boxscore']['teams']['home']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['home']['players']])
+            batting_order.append([game_data[y]['liveData']['boxscore']['teams']['home']['players'][x]['battingOrder'] if 'battingOrder' in game_data[y]['liveData']['boxscore']['teams']['home']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['home']['players']])
+            away_home.append(['home' if 'battingOrder' in game_data[y]['liveData']['boxscore']['teams']['home']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['home']['players']])
+            handedness_batter.append([game_data[y]['gameData']['players'][x]['batSide']['code'] if 'battingOrder' in game_data[y]['liveData']['boxscore']['teams']['home']['players'][x] else None for x in game_data[y]['liveData']['boxscore']['teams']['home']['players']])
+            handedness_pitcher.append([game_data[y]['gameData']['players']['ID'+str(game_data[y]['gameData']['probablePitchers']['away']['id'])]['pitchHand']['code']+'HP' if 'away' in game_data[y]['gameData']['probablePitchers'] else None for x in game_data[y]['liveData']['boxscore']['teams']['home']['players']])
+            pitcher_name.append([game_data[y]['gameData']['players']['ID'+str(game_data[y]['gameData']['probablePitchers']['away']['id'])]['fullName'] if 'away' in game_data[y]['gameData']['probablePitchers'] else None for x in game_data[y]['liveData']['boxscore']['teams']['home']['players']])
+
+
+
+        game_id_final = [item for sublist in game_id for item in sublist]
+        date_final = [item for sublist in date for item in sublist]
+        player_id_final = [item for sublist in player_id for item in sublist]
+        player_name_final = [item for sublist in player_name for item in sublist]
+        position_final = [item for sublist in position for item in sublist]
+        team_id_final = [item for sublist in team_id for item in sublist]
+        batting_order_final = [item for sublist in batting_order for item in sublist]
+        away_home_final = [item for sublist in away_home for item in sublist]
+        handedness_batter_final = [item for sublist in handedness_batter for item in sublist]
+        handedness_pitcher_final = [item for sublist in handedness_pitcher for item in sublist]
+        pitcher_name_final = [item for sublist in pitcher_name for item in sublist]
+
+        position_df = pl.DataFrame(data={'position':[1,2,3,4,5,6,7,8,9,10],'position_name':['P','C','1B','2B','3B','SS','LF','CF','RF','DH']})
+        batting_order_full = pl.DataFrame(data={'game_id':game_id_final ,
+                                                'date':date_final,
+                                                'player_id':player_id_final,
+                                                'player_name':player_name_final,
+                                                'position':position_final,
+                                                'team_id':team_id_final,
+                                                'batting_order':batting_order_final,
+                                                'away_home':away_home_final,
+                                                'handedness_batter':handedness_batter_final,
+                                                'handedness_pitcher':handedness_pitcher_final,
+                                                'pitcher_name':pitcher_name_final})
+
+        # batting_order_full = batting_order_full
+
+
+
+        batting_order_full = batting_order_full.with_columns(pl.col('position').cast(pl.Int32))
+        batting_order_full = batting_order_full.join(df_teams[['team_id', 'franchise', 'abbreviation']], on='team_id', how='left')
+        position_df = position_df.with_columns(pl.col('position').cast(pl.Int32))
+        batting_order_full = batting_order_full.join(position_df, on='position', how='left')
+        batting_order_full_opp = batting_order_full.filter(pl.col('team_id') != team_id_select)
+
+        batting_order_full = batting_order_full.filter(pl.col('team_id') == team_id_select)
+        batting_order_full_filter = batting_order_full.filter(pl.col('batting_order').cast(pl.Int32) % 100 == 0)
+
+        batting_order_full_filter = batting_order_full_filter.sort(by=['abbreviation', 'franchise', 'date', 'game_id', 'batting_order'], descending=[False, False, False, False, False]).with_row_count().drop('row_nr')
+        batting_order_full_filter = batting_order_full_filter.unique(subset=['batting_order','game_id','away_home'])
+
+        batting_order_full_filter = batting_order_full_filter.with_columns(pl.col('batting_order').cast(pl.Int32))
+
+
+        df_test_merge = batting_order_full_filter.clone()
+        df_test_merge = df_test_merge.with_columns(pl.col('*').fill_null(np.nan))
+
+        df_test_merge = df_test_merge.sort(['player_id', 'date']).fill_null(strategy='forward')
+        df_test_merge_small = df_test_merge.select([
+            'game_id', 'date', 'abbreviation', 'batting_order', 'player_id', 'player_name', 
+            'position_name', 'handedness_batter', 'handedness_pitcher', 'pitcher_name'
+        ]).sort(['date', 'game_id', 'abbreviation', 'batting_order'])
+
+        df_test_merge_small = df_test_merge_small.select(['game_id',
+            'date', 'abbreviation', 'batting_order', 'player_id', 'player_name', 
+            'position_name', 'handedness_batter', 'handedness_pitcher', 'pitcher_name'
+        ]).fill_null('')
+
+        df_test_merge_small = df_test_merge_small.with_columns([
+            (pl.col('batting_order').cast(pl.Int32) / 100).cast(pl.Int32).alias('batting_order'),
+            pl.lit(1).alias('count'),
+        ])
+
+        df_test_merge_small = df_test_merge_small.rename({'game_id': 'Game ID',
+            'date': 'Date', 'abbreviation': 'Team', 'batting_order': 'Batting', 
+            'player_id': 'Player ID', 'player_name': 'Player', 'position_name': 'Position', 
+            'handedness_batter': 'Bats', 'handedness_pitcher': 'Pitcher Hand', 
+            'pitcher_name': 'Pitcher Name'
+        })
+
+        return df_test_merge_small,batting_order_full_opp,statcast_dict
+
+
+
+    @output
+    @render.table
+    def table1():
+        df,batting_order_full_opp,statcast_dict = cached_data()
+        if df is None:
+            return pd.DataFrame({"Message": ["No Games as of this time"]})
+        team_opp = dict(zip(batting_order_full_opp['game_id'],batting_order_full_opp['abbreviation']))
+
+        df_test_merge_small_pd = df.to_pandas()
+
+        df_test_merge_small_pd['Opponent'] = df_test_merge_small_pd['Game ID'].map(team_opp)
+
+        # Create a new column with the date and opponent for the first occurrence of each game ID
+        df_test_merge_small_pd['Game'] = np.where(
+            ~df_test_merge_small_pd.duplicated(subset=['Game ID'], keep='first'),
+            0,
+            None
+        )
+
+        df_test_merge_small_pd['gameday_type'] = df_test_merge_small_pd['Game ID'].map(statcast_dict)
+        df_test_merge_small_pd['Statcast'] = np.where(
+            df_test_merge_small_pd['gameday_type'].isin(['E', 'P']),
+        True,
+        False
+        )
+
+
+        df_test_merge_small_pd['Pitcher'] = df_test_merge_small_pd['Pitcher Name'] + ' (' + df_test_merge_small_pd['Pitcher Hand'] + ')'
+
+
+        df_test_merge_small_pd['Batter'] = '<a href=https://baseballsavant.mlb.com/savant-player/'+'df_test_merge_small_pd["Player ID"].astype(str).str[2:]'+'target="_blank">'+df_test_merge_small_pd["Player"]+'</a>'
+
+
+        df_test_merge_small_pd['Gameday'] = '<a href=https://www.mlb.com/gameday/'+df_test_merge_small_pd["Game ID"].astype(int).astype(str)+' target="_blank">Gameday</a>'
+        df_test_merge_small_pd['Savant'] = np.where(
+            df_test_merge_small_pd['Statcast'],
+            '<a href=https://baseballsavant.mlb.com/gamefeed?gamePk='+df_test_merge_small_pd["Game ID"].astype(int).astype(str)+' target="_blank">Statcast</a>',
+            '(No Statcast)'
+        )
+
+        game_index = df_test_merge_small_pd.loc[~(df_test_merge_small_pd['Game'].isnull()), 'Game'].index
+
+        df_test_merge_small_pd.loc[game_index+2,'Game'] = list(df_test_merge_small_pd.loc[game_index+0,'Date'])
+
+        df_test_merge_small_pd.loc[game_index+3,'Game'] = list(df_test_merge_small_pd.loc[game_index+0,'Team'] + ' vs ' + df_test_merge_small_pd.loc[game_index+0,'Opponent'])
+
+        df_test_merge_small_pd.loc[game_index+4,'Game'] = list(df_test_merge_small_pd.loc[game_index+0,'Pitcher'])
+        df_test_merge_small_pd.loc[game_index+5,'Game'] = list(df_test_merge_small_pd.loc[game_index+0,'Gameday'])
+        df_test_merge_small_pd.loc[game_index+6,'Game'] = list(df_test_merge_small_pd.loc[game_index+0,'Savant'])
+
+        df_test_merge_small_pd['Game'] = df_test_merge_small_pd['Game'].replace(0,None).fillna('')
+
+        df_test_merge_small_output = df_test_merge_small_pd[['Game',
+
+        'Batting',
+        'Player',
+        'Position',
+        'Bats']]
+
+        df_order_style = df_test_merge_small_output.style
+
+
+        df_order_style = (df_order_style.set_precision(0)
+                        .set_table_styles(
+                            [
+
+
+                            {'selector':'th', 'props' : [('border', '1px solid black')]},
+                                
+                                                ],overwrite=False)
+                        .set_properties(**{'border': '3 px'}, overwrite=False)
+                        .set_table_styles([{
+                            'selector': 'caption',
+                            'props': [
+                            ('color', ''),
+                            ('fontname', 'Century Gothic'),
+                            ('font-size', '16px'),
+                            ('font-style', 'italic'),
+                            ('font-weight', ''),
+                            ('text-align', 'centre'),
+                            ]
+                        }, 
+                        {
+                            'selector': 'th',
+                            'props': [('font-size', '16px'), ('text-align', 'center'), ('Height', 'px'), ('color', 'black')]
+                        }, 
+                        {
+                            'selector': 'td',
+                            'props': [('text-align', 'center'), ('font-size', '16px'), ('color', 'black')]
+                        }], overwrite=False)
+
+                        .set_properties(**{'background-color': 'White', 'index': 'White', 'min-width': '20px'}, overwrite=False)
+                        .set_table_styles([{'selector': 'th:first-child', 'props': [('background-color', 'white')]}], overwrite=False)
+                        
+                        .set_table_styles([{'selector': 'th.col_heading.level0', 'props': [('background-color', '#d6d6d6')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'th.col_heading.level1', 'props': [('background-color', '#a3a3a3')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'tr', 'props': [('line-height', '20px')]}], overwrite=False)
+                        .set_properties(**{'Height': '8px'}, **{'text-align': 'center'}, overwrite=False)
+                        .hide_index()
+                        .set_properties(**{'border': '1px black solid'})
+                        .set_table_styles([{'selector': 'thead th:nth-child(1)', 'props': [('min-width', '225px')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'thead th:nth-child(2)', 'props': [('min-width', '100px')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'thead th:nth-child(3)', 'props': [('min-width', '225px')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'thead th:nth-child(4)', 'props': [('min-width', '100px')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'thead th:nth-child(5)', 'props': [('min-width', '100px')]}], overwrite=False)
+                        #   .set_table_styles([{'selector': 'thead th:nth-child(2)', 'props': [('min-width', '250px')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'thead th', 'props': [('height', '30px')]}], overwrite=False)
+                        .set_properties(
+                            **{'background-color':'#d6d6d6'},  # Apply only right border
+                            subset=df_test_merge_small_output.columns[0]  # Only affects column 1
+                                )
+                            .set_properties(
+                                    **{'border-top': 'none', 'border-bottom': 'none'}, 
+                                    subset=df_test_merge_small_output.columns[0]  # Apply only to column 1
+                            )
+                            .apply(highlight_alternate_rows, axis=0, subset=df_test_merge_small_output.columns[1:])
+        )
+
+
+        def add_thick_border(s):
+            return ['border-top: 3px solid black' if s['Batting'] == 1 else '' for _ in s]
+
+        df_order_style = df_order_style.apply(add_thick_border, axis=1)
+
+                                
+        return df_order_style
+
+    @output
+    @render.table
+    def table2():
+        df_test_merge_small,batting_order_full_opp,statcast_dict = cached_data()
+        if df_test_merge_small is None:
+            return pd.DataFrame({"Message": ["No Games as of this time"]})
+
+        df_pivot_sum = df_test_merge_small.group_by(['Player ID', 'Player','Bats']).agg([
+            pl.sum('count').alias('GP')])
+
+        df_pivot_order = df_test_merge_small.pivot(index=['Player ID', 'Player'], columns='Batting', values='count', aggregate_function='sum')
+        df_pivot_position = df_test_merge_small.pivot(index=['Player ID', 'Player'], columns='Position', values='count', aggregate_function='sum')
+        df_pivot_hand = df_test_merge_small.pivot(index=['Player ID', 'Player'], columns='Pitcher Hand', values='count', aggregate_function='sum')
+
+        df_test_merge = df_pivot_sum.join(df_pivot_order, on=['Player ID', 'Player'], how='left')
+        df_test_merge = df_test_merge.join(df_pivot_position, on=['Player ID', 'Player'], how='left')
+        df_test_merge = df_test_merge.join(df_pivot_hand, on=['Player ID', 'Player'], how='left').fill_null(0)
+        df_test_merge = df_test_merge.sort(['GP']+[str(x) for x in list(range(1,10))]
+                                            ,descending=[True]+[True]*9)
+
+
+
+        df_test_merge = df_test_merge.with_columns(
+            pl.concat_str(
+            [
+                pl.lit('<a href=https://baseballsavant.mlb.com/savant-player/'),
+                pl.col('Player ID').cast(pl.Utf8).str.slice(2),
+                pl.lit(' target="_blank">'),
+                pl.col('Player'),
+                pl.lit('</a>')
+            ]
+            ).alias('Batter')
+        )
+
+
+
+        df_test_merge = df_test_merge.select([
+            'Player ID','Batter','Bats', 'GP', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'C', '1B', '2B', '3B', 'SS', 'LF', 'CF', 'RF', 'DH', 'LHP', 'RHP'
+        ])
+
+        # First convert your data to hierarchical columns
+        cols = {
+            ('Player Info', 'Player ID'): 'Player ID',
+            ('Player Info', 'Batter'): 'Batter',
+            ('Player Info', 'Bats'): 'Bats',
+            ('Player Info', 'GP'): 'GP',
+            ('Batting Order', '1'): '1',
+            ('Batting Order', '2'): '2',
+            ('Batting Order', '3'): '3',
+            ('Batting Order', '4'): '4',
+            ('Batting Order', '5'): '5',
+            ('Batting Order', '6'): '6',
+            ('Batting Order', '7'): '7',
+            ('Batting Order', '8'): '8',
+            ('Batting Order', '9'): '9',
+            ('Position', 'C'): 'C',
+            ('Position', '1B'): '1B',
+            ('Position', '2B'): '2B',
+            ('Position', '3B'): '3B',
+            ('Position', 'SS'): 'SS',
+            ('Position', 'LF'): 'LF',
+            ('Position', 'CF'): 'CF',
+            ('Position', 'RF'): 'RF',
+            ('Position', 'DH'): 'DH',
+            ('Hand', 'LHP'): 'LHP',
+            ('Hand', 'RHP'): 'RHP'
+        }
+        # Assuming your polars DataFrame is called df
+        # Convert to pandas
+        df_pandas = df_test_merge.to_pandas()
+
+
+        df_pandas = df_pandas.replace({0: ''})
+
+        # Rename columns with multi-index
+        df_pandas.columns = pd.MultiIndex.from_tuples(
+            [(k[0], k[1]) for k in cols.keys()]
+        )
+
+
+        df_pivot_style = df_pandas.style
+        thick_border_cols = [3, 4, 13,22]  # 0-based index
+
+
+
+        # # Create a function to apply gradient only to integers
+        # def apply_gradient(val):
+        #     if isinstance(val, int):  # Check if the value is an integer
+        #         # Normalize the integer for the gradient (optional, here it's just a simple scale)
+        #         print(val)
+        #         return f'background-color: {norm(val)}'
+            
+        #     return ''  # No background for non-integer values
+        norm = plt.Normalize(vmin=0, vmax=df_pandas.select_dtypes(include=['int']).max().max())
+
+
+        def apply_gradient(val):
+            if isinstance(val, int):  # Check if the value is an integer
+                # Normalize the integer for the gradient
+                return f'background-color: {mcolors.to_hex(cmap_up(norm(val)))}'
+            return ''  # No background for non-integer values
+
+        df_pivot_style =(df_pivot_style.set_precision(0)
+                        .set_table_styles(
+                            [
+
+                            {"selector": "td:nth-child(4)", "props": [("border-right", "3px solid black")]},  # Thick right border for the 3rd column
+                            {"selector": "td:nth-child(13)", "props": [("border-right", "3px solid black")]},  # Thick right border for the 3rd column
+                            {"selector": "td:nth-child(22)", "props": [("border-right", "3px solid black")]},  # Thick right border for the 3rd column
+                            {"selector": "td:nth-child(24)", "props": [("border-right", "3px solid black")]},  # Thick right border for the 3rd column
+
+
+                            {'selector': 'thead th:nth-child(4)', 'props': [('border-right', '3px solid black')]},  # Thick right border for the 3rd header
+                            {'selector': 'thead th:nth-child(13)', 'props': [('border-right', '3px solid black')]},
+                            {'selector': 'thead th:nth-child(22)', 'props': [('border-right', '3px solid black')]},   # Thick right border for the 3rd header
+                            {'selector': 'thead th:nth-child(24)', 'props': [('border-right', '3px solid black')]},   # Thick right border for the 3rd header
+
+
+                            {'selector': 'th.col_heading.level0', 'props': [('border-right', '3px solid black')]},
+                            
+                            
+                            {'selector':'th', 'props' : [('border', '1px solid black')]},
+                                
+                                                ],overwrite=False)
+                        .set_properties(**{'border': '3 px'}, overwrite=False)
+                        .set_table_styles([{
+                            'selector': 'caption',
+                            'props': [
+                            ('color', ''),
+                            ('fontname', 'Century Gothic'),
+                            ('font-size', '16px'),
+                            ('font-style', 'italic'),
+                            ('font-weight', ''),
+                            ('text-align', 'centre'),
+                            ]
+                        }, 
+                        {
+                            'selector': 'th',
+                            'props': [('font-size', '16px'), ('text-align', 'center'), ('Height', 'px'), ('color', 'black')]
+                        }, 
+                        {
+                            'selector': 'td',
+                            'props': [('text-align', 'center'), ('font-size', '16px'), ('color', 'black')]
+                        }], overwrite=False)
+
+                        .set_properties(**{'background-color': 'White', 'index': 'White', 'min-width': '35px'}, overwrite=False)
+                        .set_table_styles([{'selector': 'th:first-child', 'props': [('background-color', 'white')]}], overwrite=False)
+                        
+                        .set_table_styles([{'selector': 'th.col_heading.level0', 'props': [('background-color', '#b6b6b6')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'th.col_heading.level1', 'props': [('background-color', '#a3a3a3')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'tr', 'props': [('line-height', '20px')]}], overwrite=False)
+                        .set_properties(**{'Height': '8px'}, **{'text-align': 'center'}, overwrite=False)
+                        .hide_index()
+                        .set_properties(**{'border': '1px black solid'})
+                        .set_table_styles([{'selector': 'thead th:nth-child(1)', 'props': [('min-width', '100px')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'thead th:nth-child(2)', 'props': [('min-width', '225px')]}], overwrite=False)
+                        #   .set_table_styles([{'selector': 'thead th:nth-child(2)', 'props': [('min-width', '250px')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'thead th', 'props': [('height', '30px')]}], overwrite=False)
+                        .apply(highlight_alternate_rows, axis=0, subset=df_pandas.columns[:])
+                            .applymap(apply_gradient)
+                            )
+        return df_pivot_style
+
+    @output
+    @render.table
+    def table3():
+
+        df_test_merge_small,batting_order_full_opp,statcast_dict = cached_data()
+        if df_test_merge_small is None:
+            return pd.DataFrame({"Message": ["No Games as of this time"]})
+        df_test_merge_small_ids = df_test_merge_small.to_pandas()[['Player ID','Player','Team']].drop_duplicates(subset='Player ID').reset_index(drop=True)
+        df_test_merge_small_ids['yahoo_name'] = df_test_merge_small_ids['Player'].apply(lambda x: (difflib.get_close_matches(x, df_2023['full'])[:1] or [None])[0])
+        df_test_merge_small_ids = df_test_merge_small_ids.merge(right=team_abb_df,left_on=['Team'],right_on=['mlb_team'],how='left')
+
+
+        #summary_2023 = summary_2023.merge(right=df_2023[['full','pos_new','percent_owned','display_position']],left_on=['cap_name','pos'],right_on=['full','pos_new'],how='left')
+        df_test_merge_small_ids = df_test_merge_small_ids.merge(right=df_2023[['full','editorial_team_abbr','average_pick','display_position']],left_on=['yahoo_name','yahoo_team'],right_on=['full','editorial_team_abbr'],how='left').dropna()
+
+        df_test_merge_small_eli = df_test_merge_small.to_pandas().merge(right=df_test_merge_small_ids[['Player ID','average_pick','display_position']],left_on=['Player ID'],right_on=['Player ID'],how='inner').fillna('')
+        df_test_merge_small_eli['average_pick'] = df_test_merge_small_eli['average_pick'].replace('-','')
+        df_test_merge_small_eli_small = df_test_merge_small_eli[df_test_merge_small_eli.apply(lambda x: x.Position not in x.display_position, axis=1)]
+        df_test_merge_small_eli_small = df_test_merge_small_eli_small[df_test_merge_small_eli_small.Position != 'DH'].reset_index(drop=True)
+        df_test_merge_small_eli_small_pivot = df_test_merge_small_eli_small.pivot_table(index=['Player ID','Player','Team','average_pick','display_position'], columns='Position', values='count', aggfunc='count').fillna(0)
+        df_test_merge_small_eli_small_pivot['GP'] = df_test_merge_small_eli_small_pivot.sum(axis=1)
+        df_test_merge_small_eli_small_pivot.index.names = ['Player ID','Player','Team','ADP','Yahoo Position']
+
+        elig_list = ['GP','C','1B','2B','3B','SS','LF','CF','RF']
+        for i in elig_list:
+            if i not in df_test_merge_small_eli_small_pivot:
+                df_test_merge_small_eli_small_pivot[i] = ''
+        df_test_merge_small_eli_small_pivot = df_test_merge_small_eli_small_pivot[['GP','C','1B','2B','3B','SS','LF','CF','RF']].sort_values(by='GP',ascending=False)
+
+        # df_test_merge_small_eli_small_pivot = df_test_merge_small_eli_small_pivot.astype({col: 'int' for col in df_test_merge_small_eli_small_pivot.columns})
+
+        # First convert your data to hierarchical columns
+        cols = {
+            ('Player Info', 'Player ID'): 'Player ID',
+            ('Player Info', 'Player'): 'Player',
+            ('Player Info', 'Team'): 'Team',
+            ('Player Info', 'ADP'): 'ADP',
+            ('Player Info', 'Yahoo Position	'): 'Yahoo Position',
+            ('Starts at New Position', 'GP'): 'GP',
+            ('Starts at New Position', 'C'): 'C',
+            ('Starts at New Position', '1B'): '1B',
+            ('Starts at New Position', '2B'): '2B',
+            ('Starts at New Position', '3B'): '3B',
+            ('Starts at New Position', 'SS'): 'SS',
+            ('Starts at New Position', 'LF'): 'LF',
+            ('Starts at New Position', 'CF'): 'CF',
+            ('Starts at New Position', 'RF'): 'RF',
+
+        }
+        # Assuming your polars DataFrame is called df
+        # Convert to pandas
+        df_yahoo_pandas = df_test_merge_small_eli_small_pivot.reset_index()
+
+        df_yahoo_pandas = df_yahoo_pandas[~df_yahoo_pandas['Yahoo Position'].str.contains('P')]
+        
+        norm = plt.Normalize(vmin=0, vmax=df_yahoo_pandas['GP'].max())
+        df_yahoo_pandas = df_yahoo_pandas.replace({0: ''})
+
+        # Rename columns with multi-index
+        df_yahoo_pandas.columns = pd.MultiIndex.from_tuples(
+            [(k[0], k[1]) for k in cols.keys()]
+        )
+
+        df_yahoo_style = df_yahoo_pandas.style
+
+        
+
+        def apply_gradient(val):
+            if isinstance(val, float):  # Check if the value is an integer
+                # Normalize the integer for the gradient
+                return f'background-color: {mcolors.to_hex(cmap_up(norm(val)))}'
+            return ''  # No background for non-integer values
+
+        df_yahoo_style = (df_yahoo_style.set_precision(0)
+                        .set_table_styles(
+                            [
+
+                            {"selector": "td:nth-child(5)", "props": [("border-right", "3px solid black")]},  # Thick right border for the 3rd column
+                            {"selector": "td:nth-child(6)", "props": [("border-right", "3px solid black")]},
+                            {"selector": "td:nth-child(14)", "props": [("border-right", "3px solid black")]},
+
+                            {'selector': 'thead th:nth-child(5)', 'props': [('border-right', '3px solid black')]}, 
+                            {'selector': 'thead th:nth-child(6)', 'props': [('border-right', '3px solid black')]},  # Thick right border for the 3rd header
+                            {'selector': 'thead th:nth-child(14)', 'props': [('border-right', '3px solid black')]},  # Thick right border for the 3rd header
+                
+                            {'selector': 'th.col_heading.level0', 'props': [('border-right', '3px solid black')]},
+                            
+                            
+                            {'selector':'th', 'props' : [('border', '1px solid black')]},
+                                
+                                                ],overwrite=False)
+                        .set_properties(**{'border': '3 px'}, overwrite=False)
+                        .set_table_styles([{
+                            'selector': 'caption',
+                            'props': [
+                            ('color', ''),
+                            ('fontname', 'Century Gothic'),
+                            ('font-size', '16px'),
+                            ('font-style', 'italic'),
+                            ('font-weight', ''),
+                            ('text-align', 'centre'),
+                            ]
+                        }, 
+                        {
+                            'selector': 'th',
+                            'props': [('font-size', '16px'), ('text-align', 'center'), ('Height', 'px'), ('color', 'black')]
+                        }, 
+                        {
+                            'selector': 'td',
+                            'props': [('text-align', 'center'), ('font-size', '16px'), ('color', 'black')]
+                        }], overwrite=False)
+
+                        .set_properties(**{'background-color': 'White', 'index': 'White', 'min-width': '35px'}, overwrite=False)
+                        .set_table_styles([{'selector': 'th:first-child', 'props': [('background-color', 'white')]}], overwrite=False)
+                        
+                        .set_table_styles([{'selector': 'th.col_heading.level0', 'props': [('background-color', '#b6b6b6')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'th.col_heading.level1', 'props': [('background-color', '#a3a3a3')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'tr', 'props': [('line-height', '20px')]}], overwrite=False)
+                        .set_properties(**{'Height': '8px'}, **{'text-align': 'center'}, overwrite=False)
+                        .hide_index()
+                        .set_properties(**{'border': '1px black solid'})
+                        
+                        .set_table_styles([{'selector': 'thead th:nth-child(1)', 'props': [('min-width', '100px')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'thead th:nth-child(2)', 'props': [('min-width', '225px')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'thead th:nth-child(3)', 'props': [('min-width', '50px')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'thead th:nth-child(4)', 'props': [('min-width', '50px')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'thead th:nth-child(5)', 'props': [('min-width', '150px')]}], overwrite=False)
+                        #   .set_table_styles([{'selector': 'thead th:nth-child(2)', 'props': [('min-width', '250px')]}], overwrite=False)
+                        .set_table_styles([{'selector': 'thead th', 'props': [('height', '30px')]}], overwrite=False)
+                        .apply(highlight_alternate_rows, axis=0, subset=df_yahoo_pandas.columns[:])
+                        .applymap(apply_gradient)
+                            )
+        return df_yahoo_style
+
+app = App(app_ui, server)