Update app.py

app.py

@@ -1,501 +1,352 @@
+import palmerpenguins
 import pandas as pd
-import seaborn as sns
-import matplotlib.pyplot as plt
-from matplotlib.pyplot import figure
-from matplotlib.offsetbox import OffsetImage, AnnotationBbox
-from scipy import stats
-import pickle
-import json
-from datetime import timedelta
-from urllib.request import urlopen
-from datetime import date
 from datetime import datetime
-import pytz
-import json
-from matplotlib.ticker import MaxNLocator
-import matplotlib.font_manager as font_manager
+from shiny import App, Inputs, Outputs, Session, reactive, render, req, ui
 import numpy as np
-
-# team_games_df = pd.read_csv('data/team_games_all.csv',index_col=[0])
-# player_games_df = pd.read_csv('data/player_games_cards.csv',index_col=[0]).sort_values(by='date').reset_index(drop=True)
-team_abv_nst = pd.read_csv('data/team_abv_nst.csv')
-#player_games_df = player_games_df.loc[:, ~player_games_df.columns.str.contains('^Unnamed')]
-#team_abv = pd.read_csv('team_abv.csv')
-#team_games_df = team_games_df.merge(right=team_abv,left_on='team',right_on='team_name',how='left').drop(columns='team_name')
-team_abv = pd.read_csv('data/team_abv.csv')
-
-import pickle
+import math
 from datetime import timedelta
+#df = pd.read_csv('summary_2024.csv',index_col=[0])
+df_game_logs = pd.read_csv('player_games_cards.csv',index_col=[0])
+df_game_logs.date = pd.to_datetime(df_game_logs.date)
+team_pp = pd.read_csv('team_games.csv',index_col=[0])
+team_pp.date = pd.to_datetime(team_pp.date)
+team_abv = pd.read_csv('team_abb.csv')
 
-# # Loop over the counter and format the API call
-# r = requests.get('https://statsapi.web.nhl.com/api/v1/schedule?startDate=2022-10-01&endDate=2023-06-01')
-# schedule = r.json()
-
-schedule = json.loads(urlopen('https://statsapi.web.nhl.com/api/v1/schedule?startDate=2023-10-07&endDate=2024-04-19').read())
-
-def flatten(t):
-    return [item for sublist in t for item in sublist]
-
-game_id = flatten([[x['gamePk'] for x in schedule['dates'][y]['games']] for y in range(0,len(schedule['dates']))])
-game_type = flatten([[x['gameType'] for x in schedule['dates'][y]['games']] for y in range(0,len(schedule['dates']))])
-game_date = flatten([[(pd.to_datetime(x['gameDate']) - timedelta(hours=8)) for x in schedule['dates'][y]['games']] for y in range(0,len(schedule['dates']))])
-game_final = flatten([[x['status']['detailedState'] for x in schedule['dates'][y]['games']] for y in range(0,len(schedule['dates']))])
-game_home = flatten([[x['teams']['home']['team']['name'] for x in schedule['dates'][y]['games']] for y in range(0,len(schedule['dates']))])
-game_away = flatten([[x['teams']['away']['team']['name'] for x in schedule['dates'][y]['games']] for y in range(0,len(schedule['dates']))])
-
-schedule_df = pd.DataFrame(data={'game_id': game_id, 'game_type':game_type,'game_date' : game_date, 'game_home' : game_home, 'game_away' : game_away,'status' : game_final})
-schedule_df = schedule_df[schedule_df.game_type == 'R'].reset_index(drop=True)
-schedule_df = schedule_df[schedule_df.status != 'Postponed']
-schedule_df = schedule_df.replace('Montréal Canadiens','Montreal Canadiens')
-
-
-
-schedule_df_merge = schedule_df.merge(right=team_abv,left_on='game_home',right_on='team_name',how='left')
-schedule_df_merge = schedule_df_merge.merge(right=team_abv,left_on='game_away',right_on='team_name',how='left')
-schedule_df_merge = schedule_df_merge.drop(columns={'team_name_x','team_name_y'})
-schedule_df_merge = schedule_df_merge.rename(columns={'team_abv_x' : 'team_abv_home','team_abv_y' : 'team_abv_away'})
-
-
-
-
-#schedule_df_merge.game_date = pd.to_datetime(schedule_df_merge['game_date']).dt.tz_convert(tz='US/Eastern').dt.date
-# schedule_df_merge = schedule_df_merge.set_index(pd.DatetimeIndex(schedule_df_merge.game_date).strftime('%Y-%m-%d'))
-schedule_df_merge.index = pd.to_datetime(schedule_df_merge.game_date)
-schedule_df_merge = schedule_df_merge.drop(columns='game_date')
-#schedule_df_merge.index = schedule_df_merge.index.tz_convert('US/Pacific')
-schedule_df_merge.index = schedule_df_merge.index.date
-schedule_df_merge = schedule_df_merge.sort_index()
-schedule_df_merge = schedule_df_merge[schedule_df_merge.index <= date(2024,5,1)]
-
-schedule_df_merge_final = schedule_df_merge[schedule_df_merge['status']=='Final']
-schedule_ccount_df = pd.DataFrame(data={'date':list(schedule_df_merge_final.index)*2,'team':list(schedule_df_merge_final.team_abv_away)+list(schedule_df_merge_final.team_abv_home)}).sort_values(by='date').reset_index(drop=True)
-schedule_ccount_df['team_game'] = schedule_ccount_df.groupby('team').cumcount()+1
-schedule_ccount_df.date = pd.to_datetime(schedule_ccount_df.date)
-
-today = pd.to_datetime(datetime.now(pytz.timezone('US/Pacific')).strftime('%Y-%m-%d'))
-team_schdule = schedule_df_merge[(schedule_df_merge['team_abv_home']=='EDM')|(schedule_df_merge['team_abv_away']=='EDM')]
-team_schdule_live = team_schdule[team_schdule.index <= today]
-team_schdule_live.head()
-
-team_games_df = pd.read_csv('data/team_games_all.csv',index_col=[0])
-player_games_df = pd.read_csv('data/player_games_cards.csv',index_col=[0]).sort_values(by='date').reset_index(drop=True)
-team_abv_df = pd.read_csv('data/team_abv.csv')
-player_games_df = player_games_df.loc[:, ~player_games_df.columns.str.contains('^Unnamed')]
-
-team_games_df = team_games_df.merge(right=team_abv_df,left_on='team',right_on='team_name',how='left').drop(columns='team_name')
-
-player_games_df = player_games_df.drop_duplicates(subset=['player_id','date'],keep='last').reset_index(drop=True)
-player_games_df.date = pd.to_datetime(player_games_df.date)
-team_games_df = team_games_df[team_games_df['date']=='Final']
-schedule_df_merge_final = schedule_df_merge[schedule_df_merge['status']=='Final']
-schedule_ccount_df = pd.DataFrame(data={'date':list(schedule_df_merge_final.index)*2,'team':list(schedule_df_merge_final.team_abv_away)+list(schedule_df_merge_final.team_abv_home)}).sort_values(by='date').reset_index(drop=True)
-schedule_ccount_df['team_game'] = schedule_ccount_df.groupby('team').cumcount()+1
-schedule_ccount_df.date = pd.to_datetime(schedule_ccount_df.date)
-team_games_df['team_game'] = team_games_df.groupby('team').cumcount()+1
-player_games_df = player_games_df.merge(right=schedule_ccount_df,left_on=['Team','date'],right_on=['team','date'],how='left')
-player_games_df['player_game'] = player_games_df.groupby('player_id').cumcount()+1
-
-date_range_list = pd.date_range(start=player_games_df.date.min()+timedelta(days=6),end=player_games_df.date.max())
-
-
-team_abv_nst_dict = {'All':''} | team_abv_nst.set_index('team_abv')['team_name'].to_dict()
-
-position_dict = {'All':'','F':'Forwards','D':'Defense'}
-
-player_games_df = player_games_df.rename(columns={'Total Points_pp':'PP Points'})
-
-stat_input_list = ['TOI', 'Goals', 'Total Assists',
-       'First Assists',  'Total Points', 'PP Points','Shots', 'Hits',
-        'Shots Blocked']
-
-
-df_cum_stat_total = player_games_df.groupby(['player_id','Player','Position']).agg(
-    GP = ('GP','count'),
-    Total_Points = ('Total Points','sum')
-        ).reset_index()
-
-df_all_sort = df_cum_stat_total.copy()
-stat_pick = 'Total_Points'
-count=11
-not_position = ''
-team = ''
-df_all_sort = df_all_sort[(df_all_sort['Position']!=not_position)]
-df_all_sort[stat_pick+' per game'] = df_all_sort[stat_pick]/df_all_sort['GP']
-df_all_sort[stat_pick+' Rank'] = df_all_sort[stat_pick].rank(ascending=False,method='min')
-df_all_sort = df_all_sort[df_all_sort[stat_pick+' Rank']<=count]
-df_all_sort[stat_pick+' per game Rank'] = df_all_sort[stat_pick+' per game'].rank(ascending=False,method='min')
-# #df_all_sort.sort_values(by=[stat_pick,stat_pick+' per game','Total Points'],ascending = (False, False,False))
-df_all_sort_list = df_all_sort[df_all_sort[stat_pick+' Rank']<max(df_all_sort[stat_pick+' Rank'])].sort_values(by=[stat_pick,stat_pick+' per game','Total_Points'],ascending = (False, False,False))
-# # df_all_sort = df_all_sort.sort_values(by=[stat_pick,stat_pick+' per game','Total Points'],ascending = (False, False,False))[(df_all_sort['Position']!=not_position)&(df_all_sort['Team']!=team)].head(count)['Player']
-temp_df = df_all_sort[df_all_sort[stat_pick+' Rank']==max(df_all_sort[stat_pick+' Rank'])]#[stat_pick+' per game Rank'].rank().sort_values(ascending=True).reset_index(drop=True)[count-len(df_all_sort_list)-1]
-temp_df['temp'] =  temp_df[stat_pick+' per game Rank'].rank()#.sort_values(ascending=True)#.reset_index(drop=True)
-temp_df = temp_df.sort_values(by='temp',ascending=True)#.reset_index(drop=True)
-temp = temp_df[temp_df['temp']<=(count-len(df_all_sort_list))]
-
-players_list = list(pd.concat([df_all_sort_list,temp]).reset_index(drop=True)['player_id'])
-
-
-rookie_df = pd.read_csv('data/player_rookies.csv',index_col=[0])
-rookie_list = rookie_df.player_id.values
-
+df_game_logs_2 = df_game_logs.copy()
+team_pp_2 = team_pp.copy()
 
-skater_dict = df_cum_stat_total.sort_values(by=['Total_Points','GP'],ascending=[False,True]).drop_duplicates(subset='player_id').set_index('player_id')#.sort_values(by='Player')
-#skater_dict['skater_team'] = skater_dict.Player + ' - ' + skater_dict.Team
-skater_dict = skater_dict['Player'].to_dict()
-# players_list = list(df_all_sort['Player'])
-print(players_list)
-
-
-from shiny import ui, render, App
-from shiny import App, reactive, ui
-from shiny.ui import h2, tags
-import matplotlib.image as mpimg
-
-# app_ui = ui.page_fluid(
-
-#     # ui.output_plot("plot"),
-#     #ui.h2('MLB Batter Launch Angle vs Exit Velocity'),
-#     ui.layout_sidebar(
-#         ui.panel_sidebar(
-#             ui.input_select("id", "Select Batter",batter_dict),
-
-#             ui.input_select("plot_id", "Select Plot",{'scatter':'Scatter Plot','dist':'Distribution Plot'})))
-#         ,
-
-#     ui.panel_main(ui.output_plot("plot",height = "750px",width="1250px")),
-#     #ui.download_button('test','Download'),
-# )
-#import shinyswatch
 app_ui = ui.page_fluid(
-    #shinyswatch.theme.cosmo(),
     ui.layout_sidebar(
-    
-    # Available themes:
-    #  cerulean, cosmo, cyborg, darkly, flatly, journal, litera, lumen, lux,
-    #  materia, minty, morph, pulse, quartz, sandstone, simplex, sketchy, slate,
-    #  solar, spacelab, superhero, united, vapor, yeti, zephyr
-        
-      ui.panel_sidebar( 
-          ui.input_select("id", "Select Skater (max. 10 Skaters)",skater_dict,width=1,selected=list(players_list[0:10]),selectize=True,multiple=True),
-          ui.input_select("stat", "Stat Input",stat_input_list,width=1,size=1,selectize=False,selected='Total Points'),
-          ui.input_select("team_select", "Team",team_abv_nst_dict,width=1,size=1,selectize=False,selected='All'),
-          ui.input_select("position_select", "Position",position_dict,width=1,size=1,selectize=False,selected='All'),
-          ui.input_date("date", "Date input",value = datetime.today().date() - timedelta(days=1),min='2023-10-10', max=datetime.today().date() - timedelta(days=1)),
-          ui.input_switch("rookie_switch", "Rookies Only"),
-          ui.output_table("result"),
-          width=3),
-          
-         
-        
-        ui.panel_main(
-            
-            ui.navset_tab(
-                    ui.nav("Chart Races",
-                    ui.panel_main(
-                        ui.output_plot("plot",height = "1200px",width="1200px")),
-                           )
-                    
-                           
-
-        ))))
-        #  ui.row(
-        #         ui.column(
-        #             3,
-        #                 ui.input_date("x", "Date input"),),
-        #         ui.column(
-        #             1,
-        #             ui.input_select("level_id", "Select Level",level_dict,width=1)),
-        #         ui.column(
-        #             3,
-        #             ui.input_select("stat_id", "Select Stat",plot_dict_small,width=1)),
-        #         ui.column(
-        #             2,
-        #             ui.input_numeric("n", "Rolling Window Size", value=50)),
-        #         ),
-        #             ui.output_table("result_batters")),
-
-                # ui.nav(
-                #     "Pitchers",
-
-                #                 ui.row(
-                # ui.column(
-                #     3,
-                #     ui.input_select("id_pitch", "Select Pitcher",pitcher_dict,width=1,selected=675911),
-                #     ),
-                # ui.column(
-                #     1,
-                #     ui.input_select("level_id_pitch", "Select Level",level_dict,width=1)),
-                # ui.column(
-                #     3,
-                #     ui.input_select("stat_id_pitch", "Select Stat",plot_dict_small_pitch,width=1)),
-                # ui.column(
-                #     2,
-                #         ui.input_numeric("n_pitch", "Rolling Window Size", value=50)),
-                # ),
-                #     ui.output_table("result_pitchers")),
-#             )
-#         )
-# )
-
-
-
-
-#from urllib.request import Request, urlopen
-
-# importing OpenCV(cv2) module
-
-
-
-
-def server(input, output, session):
-
-
-    @reactive.Effect
-    def _():
-        
-
-        team_select_list = [input.team_select()]    
-        position_select_list =  [input.position_select()]    
-
-        if team_select_list[0] == 'All':
-            team_select_list = team_abv_nst.team_abv.unique()
-
-        if position_select_list[0] == 'All':
-            position_select_list = player_games_df.Position.unique()     
-
-        elif position_select_list[0] == 'F':
-            position_select_list = player_games_df[player_games_df.Position != 'D'].Position.unique()     
-
-        else:
-            position_select_list = ['D'] 
+ 
+        ui.panel_sidebar(
+                ui.input_select(
+                    "selection_mode",
+                    "Selection mode",
+                    {"none": "(None)", "single": "Single", "multiple": "Multiple"},
+                    selected="multiple",
+                ),
+
+                ui.input_switch("gridstyle", "Grid", True),
+                ui.input_switch("fullwidth", "Take full width", True),
+                ui.input_switch("fixedheight", "Fixed height", True),
+                ui.input_switch("filters", "Filters", True),
+                ui.input_date_range("date_range_id", "Date range input",start = df_game_logs.date.min(),
+                                     end = datetime.today().date()- timedelta(days=1),width=2,min='2023-10-10',
+                                       max=datetime.today().date() - timedelta(days=1)),width=2),
+
+   ui.panel_main(     
+        ui.navset_tab(
+            ui.nav("Total",
+                ui.tags.h1("NHL Leaderboards — 2023-24 Season"),
+                ui.div({"style": "font-size:1.6em;"},ui.output_text("txt")),
+                ui.tags.h5("Created By: @TJStats,     Data: Natural Stat Trick"),
+                ui.output_data_frame("grid"),
+        ),
+         ui.nav("Per Game",
+                ui.tags.h1("NHL Leaderboards — 2023-24 Season — Per Game"),
+                ui.div({"style": "font-size:1.6em;"},ui.output_text("txt_per_game")),
+                ui.tags.h5("Created By: @TJStats,     Data: Natural Stat Trick"),
+                ui.output_data_frame("grid_per_game"),
+        ),
         
-        print(team_select_list)
-
+            ui.nav("Per 60",
+                ui.tags.h1("NHL Leaderboards — 2023-24 Season — Per 60"),
+                ui.div({"style": "font-size:1.6em;"},ui.output_text("txt_60")),
+                ui.tags.h5("Created By: @TJStats,     Data: Natural Stat Trick"),
+                ui.output_data_frame("grid_60"),
+        ),))))
 
-        if input.rookie_switch():
 
-            df_cum_stat_total = player_games_df[(player_games_df.date <= pd.to_datetime(input.date()))
-                                                &(player_games_df.player_id.isin(rookie_list))
-                                                &(player_games_df.Team.isin(team_select_list))
-                                                &(player_games_df.Position.isin(position_select_list))].groupby(['player_id','Player','Position']).agg(
-                GP = ('GP','count'),
-                Total_Points = (f'{input.stat()}','sum')
-                    ).reset_index()
-            
-        else:
-            df_cum_stat_total = player_games_df[(player_games_df.date <= pd.to_datetime(input.date()))
-                                                &(player_games_df.Team.isin(team_select_list))
-                                                &(player_games_df.Position.isin(position_select_list))].groupby(['player_id','Player','Position']).agg(
-                GP = ('GP','count'),
-                Total_Points = (f'{input.stat()}','sum')
-                    ).reset_index()
-
-        df_all_sort = df_cum_stat_total.copy()
-        stat_pick = 'Total_Points'
-        count=6
-        not_position = ''
-        team = ''
-        df_all_sort = df_all_sort[(df_all_sort['Position']!=not_position)]
-        df_all_sort[stat_pick+' per game'] = df_all_sort[stat_pick]/df_all_sort['GP']
-        df_all_sort[stat_pick+' Rank'] = df_all_sort[stat_pick].rank(ascending=False,method='min')
-        df_all_sort = df_all_sort[df_all_sort[stat_pick+' Rank']<=count]
-        df_all_sort[stat_pick+' per game Rank'] = df_all_sort[stat_pick+' per game'].rank(ascending=False,method='min')
-        # #df_all_sort.sort_values(by=[stat_pick,stat_pick+' per game','Total Points'],ascending = (False, False,False))
-        df_all_sort_list = df_all_sort[df_all_sort[stat_pick+' Rank']<max(df_all_sort[stat_pick+' Rank'])].sort_values(by=[stat_pick,stat_pick+' per game','Total_Points'],ascending = (False, False,False))
-        # # df_all_sort = df_all_sort.sort_values(by=[stat_pick,stat_pick+' per game','Total Points'],ascending = (False, False,False))[(df_all_sort['Position']!=not_position)&(df_all_sort['Team']!=team)].head(count)['Player']
-        temp_df = df_all_sort[df_all_sort[stat_pick+' Rank']==max(df_all_sort[stat_pick+' Rank'])]#[stat_pick+' per game Rank'].rank().sort_values(ascending=True).reset_index(drop=True)[count-len(df_all_sort_list)-1]
-        temp_df['temp'] =  temp_df[stat_pick+' per game Rank'].rank()#.sort_values(ascending=True)#.reset_index(drop=True)
-        temp_df = temp_df.sort_values(by='temp',ascending=True)#.reset_index(drop=True)
-        temp = temp_df[temp_df['temp']<=(count-len(df_all_sort_list))]
-
-        players_list_new = list(pd.concat([df_all_sort_list,temp]).reset_index(drop=True)['player_id'])
-
-
-        skater_dict = df_cum_stat_total.sort_values(by=['Total_Points','GP'],ascending=[False,True]).drop_duplicates(subset='player_id').set_index('player_id')#.sort_values(by='Player')
-        #skater_dict['skater_team'] = skater_dict.Player + ' - ' + skater_dict.Team
-        skater_dict = skater_dict['Player'].to_dict()
-        # players_list = list(df_all_sort['Player'])
-        
-        ui.update_select(
-            "id",
-            label="Select Skater (max. 10 Skaters)",
-            choices=skater_dict,
-            selected=list(players_list_new[0:10]))
-  
+def server(input: Inputs, output: Outputs, session: Session):
 
     @output
-    @render.table
-    def result():
-        if input.rookie_switch():
-
-            return player_games_df[(player_games_df.date <= pd.to_datetime(input.date()))&(player_games_df.player_id.isin(rookie_list))].groupby(['player_id','Player','Position']).agg(
-                GP = ('GP','count'),
-                Stat = (f'{input.stat()}','sum')
-                    ).reset_index().sort_values(by=['Stat','GP'],ascending=[False,True]).reset_index(drop=True)
-            
-        else:
-            return player_games_df[player_games_df.date <= pd.to_datetime(input.date())].groupby(['player_id','Player','Position']).agg(
-                GP = ('GP','count'),
-                Stat = (f'{input.stat()}','sum')
-                    ).reset_index().sort_values(by=['Stat','GP'],ascending=[False,True]).reset_index(drop=True)
+    @render.text
+    def txt():
+            if input.date_range_id()[0].year != input.date_range_id()[1].year:
 
+                return f'{input.date_range_id()[0].strftime("%B %d, %Y")} to {input.date_range_id()[1].strftime("%B %d, %Y")}'
+            else:
+                if input.date_range_id()[0].month != input.date_range_id()[1].month:
+                    return f'{input.date_range_id()[0].strftime("%B %d")} to {input.date_range_id()[1].strftime("%B %d, %Y")}'
+                else:
+                    return f'{input.date_range_id()[0].strftime("%B %d")} to {input.date_range_id()[1].strftime("%d, %Y")}'    
 
     @output
-    @render.plot(alt="A histogram")
-    def plot():
+    @render.text
+    def txt_per_game():
+            if input.date_range_id()[0].year != input.date_range_id()[1].year:
+
+                return f'{input.date_range_id()[0].strftime("%B %d, %Y")} to {input.date_range_id()[1].strftime("%B %d, %Y")}'
+            else:
+                if input.date_range_id()[0].month != input.date_range_id()[1].month:
+                    return f'{input.date_range_id()[0].strftime("%B %d")} to {input.date_range_id()[1].strftime("%B %d, %Y")}'
+                else:
+                    return f'{input.date_range_id()[0].strftime("%B %d")} to {input.date_range_id()[1].strftime("%d, %Y")}'    
+    @output
+    @render.text
+    def txt_60():
+            if input.date_range_id()[0].year != input.date_range_id()[1].year:
 
+                return f'{input.date_range_id()[0].strftime("%B %d, %Y")} to {input.date_range_id()[1].strftime("%B %d, %Y")}'
+            else:
+                if input.date_range_id()[0].month != input.date_range_id()[1].month:
+                    return f'{input.date_range_id()[0].strftime("%B %d")} to {input.date_range_id()[1].strftime("%B %d, %Y")}'
+                else:
+                    return f'{input.date_range_id()[0].strftime("%B %d")} to {input.date_range_id()[1].strftime("%d, %Y")}'    
 
-        team_select_list = [input.team_select()]    
-        position_select_list =  [input.position_select()]    
 
+    @output
+    @render.data_frame
+    def grid():
+        height = 750 if input.fixedheight() else None
+        width = "100%" if input.fullwidth() else "fit-content"
 
+        df_game_logs = df_game_logs_2.copy()
+        team_pp = team_pp_2.copy()
 
-        if team_select_list[0] == 'All':
-            team_select_title = 'NHL '
-        else:
-            team_select_title = f'{team_abv_nst_dict[team_select_list[0]]} '
-            
+        df_game_logs = df_game_logs[(df_game_logs.date.dt.date >= input.date_range_id()[0])&(df_game_logs.date.dt.date <= input.date_range_id()[1])]
 
-        if position_select_list[0] == 'All':
-            position_select_title = '' 
 
-        elif position_select_list[0] == 'F':
-            position_select_title = 'Forwards '
+        player_id_team = df_game_logs.sort_values(by='date').groupby('player_id').tail(1)[['player_id','Team']].set_index(['player_id'])
+        team_pp = team_pp.merge(team_abv)
 
-        else:
-            position_select_title = 'Defense '
+        df_game_logs = df_game_logs.merge(right=team_pp, left_on = ['date','Team'], right_on = ['date','abb'])
+        df_game_logs['Team'] = df_game_logs.player_id.map(player_id_team.to_dict()['Team'])
 
-        rookie = ''
-        if input.rookie_switch():
-            rookie = 'Rookie '
-            
-        i = 0
-        #rookie = ''
-        current_season = '2023'
-        start_season = '2024'
 
-        # player_lookup_list = ['Connor McDavid','David Pastrnak','Nathan MacKinnon']
+        players_games_og_all_summary = df_game_logs.groupby(['player_id','Player','pos','Team']).agg(
+            GP = ('GP','sum'),
+            TOI = ('TOI','sum'),
+            Goals = ('Goals','sum'),
+            Assists = ('Total Assists','sum'),
+            First_Assists = ('First Assists','sum'),
+            Total_Points = ('Total Points','sum'),
+            ixG = ('ixG','sum'),
+            #GSAx = ('Goals'-'ixG','sum'),
+            Shots = ('Shots','sum'),
+            iCF = ('iCF','sum'),
+            iSCF = ('iSCF','sum'),
+            iHDCF = ('iHDCF','sum'),
+            Hits = ('Hits','sum'),
+            Shots_Blocked = ('Shots Blocked','sum'),
+            TOI_pp = ('TOI_pp','sum'),
+            Total_Points_pp = ('Total Points_pp','sum'),
+            TOI_pp_team = ('pp_toi','sum'))#.reset_index()
 
 
-        type(input.id())
-        print(input.id())
-        player_lookup_list = list(input.id())[0:10]
+        players_games_og_all_summary['1A_percent'] = (players_games_og_all_summary.First_Assists / players_games_og_all_summary.Assists).round(3)
+        players_games_og_all_summary['PP%'] = (players_games_og_all_summary.TOI_pp / players_games_og_all_summary.TOI_pp_team).round(3)
+        players_games_og_all_summary['G-ixG'] = players_games_og_all_summary.Goals - players_games_og_all_summary.ixG
+        players_games_og_all_summary['S+H+B'] = players_games_og_all_summary.Shots + players_games_og_all_summary.Hits + players_games_og_all_summary.Shots_Blocked
+        players_games_og_all_summary.TOI = players_games_og_all_summary.TOI.round(2)
 
-        stat = input.stat()
-        sns.set_theme(style="whitegrid", palette="pastel")
-        #print(type([input.date()))
-        date_range_list = [pd.to_datetime(input.date())]
-        for k in range(len(date_range_list)):
-            print(date_range_list[k])
-            stat = input.stat()
-            team_schedule_url_merge = []
-            max_games_player = []
-            max_games_team = []
-            max_stat = []
-            per_game = False
-            for i in range(0,len(player_lookup_list)):
-                team_schedule_url_merge.append(player_games_df[(player_games_df.player_id == int(player_lookup_list[i]))&(date_range_list[k] >= player_games_df.date)].reset_index(drop=True))
-                #print('touble',i, player_lookup_list[i],len(player_games_df[(player_games_df.player_id == player_lookup_list[i])]))
-                team_schedule_url_merge[i].index = team_schedule_url_merge[i].team_game
-                team_schedule_url_merge[i] = team_schedule_url_merge[i].reindex(np.arange(team_schedule_url_merge[i].team_game.min(), team_schedule_url_merge[i].team_game.max() + 1)).reset_index(drop=True)
-                #team_schedule_url_merge[0]['team_game'] = team_schedule_url_merge[0]['index']
-                #team_schedule_url_merge[0]['player_game'] = 
-                #schedule_ccount_df[schedule_ccount_df['team'].isin(team_schedule_url_merge[0].Team.unique())].merge(right=team_schedule_url_merge[0],left_on=['date','team'],right_on=['date','Team'],how='left')
+        players_games_og_all_summary['1A_percent'] = [f'{str(round(x*100,1))}%' if not math.isnan(x) else '' for x in players_games_og_all_summary['1A_percent']]
+        players_games_og_all_summary['PP%'] = [f'{str(round(x*100,1))}%' if not math.isnan(x) else '' for x in players_games_og_all_summary['PP%']]
 
-                team_schedule_url_merge[i]['stat'] = team_schedule_url_merge[i][stat].cumsum()
+        
 
+        output_df = players_games_og_all_summary.reset_index(drop=False)[['Player', 'Team', 'pos', 'GP', 'TOI', 'Goals',
+                                                                         'Assists', 'Total_Points','Total_Points_pp', 'Shots','Hits', 'Shots_Blocked', 'S+H+B', 
+                                                                          '1A_percent', 'PP%']]
 
-                #team_schedule_url_merge[i]['stat'] = team_schedule_url_merge[i][stat_pick]
-                team_schedule_url_merge[i] = team_schedule_url_merge[i].append(team_schedule_url_merge[i]).sort_index()
-                team_schedule_url_merge[i] = team_schedule_url_merge[i].append(team_schedule_url_merge[i].iloc[0]).sort_index().reset_index(drop=True)
 
-                team_schedule_url_merge[i]['team_game'][0] = 0
-                team_schedule_url_merge[i]['player_game'][0] = 0
-                team_schedule_url_merge[i]['stat'][0] = 0
+        output_df.columns = ['Player', 'Team', 'Pos', 'GP', 'TOI', 'Goals','Assists', 'Points','PPP', 'Shots','Hits', 'Blocks', 'S+H+B', 
+                                                                          '1A%', 'PP%']
 
-                for j in range(1,len(team_schedule_url_merge[i]),2):
-                    team_schedule_url_merge[i]['player_game'][j] = team_schedule_url_merge[i]['player_game'][j]-1
-                    team_schedule_url_merge[i]['team_game'][j] = team_schedule_url_merge[i]['team_game'][j]-1
-                    team_schedule_url_merge[i]['stat'][j] = team_schedule_url_merge[i]['stat'][j] - team_schedule_url_merge[i][stat][j]
 
-                if len(team_schedule_url_merge[i]) >3:     
-                    if pd.isna(team_schedule_url_merge[i].iloc[3]['player_game']) and pd.isna(team_schedule_url_merge[i].iloc[1]['player_game']) == True:
-                        team_schedule_url_merge[i]['player_game'][2] = np.nan
-                        team_schedule_url_merge[i]['stat'][2] = np.nan
 
-                if len(team_schedule_url_merge[i]) >3:   
-                    if pd.isna(team_schedule_url_merge[i].iloc[len(team_schedule_url_merge[i])-1]['player_game']) == True:
-                        team_schedule_url_merge[i]['stat'][len(team_schedule_url_merge[i])-1] = np.nanmax(team_schedule_url_merge[i]['stat'])
 
-                if not (team_schedule_url_merge[i]['team_game'].values[1] == team_schedule_url_merge[i]['player_game'].values[0]):   
-                    team_schedule_url_merge[i].loc[0,'team_game'] = np.nan
 
+        if input.gridstyle():
+            return render.DataGrid(
+                output_df,
+                row_selection_mode=input.selection_mode(),
+                height=height,
+                width='fit-content',
+                filters=input.filters(),
+            )
+        else:
+            return render.DataTable(
+                output_df,
+                row_selection_mode=input.selection_mode(),
+                height=height,
+                width='fit-content',
+                filters=input.filters(),
+            )
+        
 
-                max_games_player.append(np.around(np.nanmax(team_schedule_url_merge[i]['player_game'])))
-                max_games_team.append(np.around(np.nanmax(team_schedule_url_merge[i]['team_game'])))
-                max_stat.append((np.around(np.nanmax(team_schedule_url_merge[i]['stat']))))
 
+    @output
+    @render.data_frame
+    def grid_per_game():
+        height = 750 if input.fixedheight() else None
+        width = "100%" if input.fullwidth() else "fit-content"
+
+        df_game_logs = df_game_logs_2.copy()
+        team_pp = team_pp_2.copy()
+
+        df_game_logs = df_game_logs[(df_game_logs.date.dt.date >= input.date_range_id()[0])&(df_game_logs.date.dt.date <= input.date_range_id()[1])]
+
+
+        player_id_team = df_game_logs.sort_values(by='date').groupby('player_id').tail(1)[['player_id','Team']].set_index(['player_id'])
+        team_pp = team_pp.merge(team_abv)
+
+        df_game_logs = df_game_logs.merge(right=team_pp, left_on = ['date','Team'], right_on = ['date','abb'])
+        df_game_logs['Team'] = df_game_logs.player_id.map(player_id_team.to_dict()['Team'])
+
+
+        players_games_og_all_summary = df_game_logs.groupby(['player_id','Player','pos','Team']).agg(
+            GP = ('GP','sum'),
+            TOI = ('TOI','sum'),
+            Goals = ('Goals','sum'),
+            Assists = ('Total Assists','sum'),
+            First_Assists = ('First Assists','sum'),
+            Total_Points = ('Total Points','sum'),
+            ixG = ('ixG','sum'),
+            #GSAx = ('Goals'-'ixG','sum'),
+            Shots = ('Shots','sum'),
+            iCF = ('iCF','sum'),
+            iSCF = ('iSCF','sum'),
+            iHDCF = ('iHDCF','sum'),
+            Hits = ('Hits','sum'),
+            Shots_Blocked = ('Shots Blocked','sum'),
+            TOI_pp = ('TOI_pp','sum'),
+            Total_Points_pp = ('Total Points_pp','sum'),
+            TOI_pp_team = ('pp_toi','sum'))#.reset_index()
+
+
+        players_games_og_all_summary['1A_percent'] = (players_games_og_all_summary.First_Assists / players_games_og_all_summary.Assists).round(3)
+        players_games_og_all_summary['PP%'] = (players_games_og_all_summary.TOI_pp / players_games_og_all_summary.TOI_pp_team).round(3)
+        players_games_og_all_summary['G-ixG'] = players_games_og_all_summary.Goals - players_games_og_all_summary.ixG
+        players_games_og_all_summary['S+H+B'] = players_games_og_all_summary.Shots + players_games_og_all_summary.Hits + players_games_og_all_summary.Shots_Blocked
+        players_games_og_all_summary.TOI = players_games_og_all_summary.TOI.round(2)
+        
+        players_games_og_all_summary['1A_percent'] = [f'{str(round(x*100,1))}%' if not math.isnan(x) else '' for x in players_games_og_all_summary['1A_percent']]
+        players_games_og_all_summary['PP%'] = [f'{str(round(x*100,1))}%' if not math.isnan(x) else '' for x in players_games_og_all_summary['PP%']]
 
+        players_games_og_all_summary[['TOI', 'Goals', 'ixG', 'G-ixG','Assists', 
+                              'First_Assists', 'Total_Points','Total_Points_pp', 
+                              'Shots','Hits', 'Shots_Blocked', 'S+H+B', ]] = players_games_og_all_summary[['TOI', 'Goals', 'ixG', 'G-ixG','Assists', 
+                                                                                                            'First_Assists', 'Total_Points','Total_Points_pp', 
+                                                                                                            'Shots','Hits', 'Shots_Blocked', 'S+H+B', ]].divide(players_games_og_all_summary.GP,axis=0).round(2)
 
+        output_df = players_games_og_all_summary.reset_index(drop=False)[['Player', 'Team', 'pos',  'GP', 'TOI', 'Goals',
+                                                                         'Assists', 'Total_Points','Total_Points_pp', 'Shots','Hits', 'Shots_Blocked', 'S+H+B', 
+                                                                          '1A_percent', 'PP%']]
 
 
+        output_df.columns = ['Player', 'Team', 'Pos', 'GP', 'TOI/GP', 'Goals/GP','Assists/GP', 'Points/GP','PPP/GP', 'Shots/GP','Hits/GP', 'Blocks/GP', 'S+H+B/GP', 
+                                                                          '1A%', 'PP%']
 
-            fig, ax = plt.subplots(figsize=(15,15))
-            cgfont = {'fontname':'Century Gothic'}
-            font = font_manager.FontProperties(family='Century Gothic',
-                                                style='normal', size=14)
 
 
-            ax.axhline(0,color='black',linestyle ="--",linewidth=2,alpha=1.0,label='Missed Games')
-            ax.axhline(0,color='black',linestyle ="-",linewidth=2,alpha=1.0)
 
 
-            if 'Total' in stat:
-                stat = stat.replace('Total ',"")
+        if input.gridstyle():
+            return render.DataGrid(
+                output_df,
+                row_selection_mode=input.selection_mode(),
+                height=height,
+                width='fit-content',
+                filters=input.filters(),
+            )
+        else:
+            return render.DataTable(
+                output_df,
+                row_selection_mode=input.selection_mode(),
+                height=height,
+                width='fit-content',
+                filters=input.filters(),
+            )
 
 
-            colour_scheme = ['#648FFF','#785EF0','#DC267F','#FE6100','#FFB000','#FAEF3B','#861318','#2ED3BC','#341BBF','#B37E2C']
 
-            for i in range(len(team_schedule_url_merge)):
-                sns.lineplot(team_schedule_url_merge[i].reset_index()['team_game'],team_schedule_url_merge[i].reset_index()['stat'],linewidth=3-i*.2,color=colour_scheme[i])
-                plt.plot(team_schedule_url_merge[i]['team_game'],team_schedule_url_merge[i]['stat'],color=ax.lines[i*2+2].get_color(),label=str(i+1)+'. '+team_schedule_url_merge[i]['Player'][0]+', '+str(int(max_stat[i]))+' '+stat+' in '+str(int(max(team_schedule_url_merge[i]['player_game'])))+' Games',linewidth=6)
-                ax.lines[i*2+2].set_linestyle("--")
+    @output
+    @render.data_frame
+    def grid_60():
+        height = 750 if input.fixedheight() else None
+        width = "100%" if input.fullwidth() else "fit-content"
+
+        df_game_logs = df_game_logs_2.copy()
+        team_pp = team_pp_2.copy()
+
+        df_game_logs = df_game_logs[(df_game_logs.date.dt.date >= input.date_range_id()[0])&(df_game_logs.date.dt.date <= input.date_range_id()[1])]
+
+
+        player_id_team = df_game_logs.sort_values(by='date').groupby('player_id').tail(1)[['player_id','Team']].set_index(['player_id'])
+        team_pp = team_pp.merge(team_abv)
+
+        df_game_logs = df_game_logs.merge(right=team_pp, left_on = ['date','Team'], right_on = ['date','abb'])
+        df_game_logs['Team'] = df_game_logs.player_id.map(player_id_team.to_dict()['Team'])
+
+
+        players_games_og_all_summary = df_game_logs.groupby(['player_id','Player','pos','Team']).agg(
+            GP = ('GP','sum'),
+            TOI = ('TOI','sum'),
+            Goals = ('Goals','sum'),
+            Assists = ('Total Assists','sum'),
+            First_Assists = ('First Assists','sum'),
+            Total_Points = ('Total Points','sum'),
+            ixG = ('ixG','sum'),
+            #GSAx = ('Goals'-'ixG','sum'),
+            Shots = ('Shots','sum'),
+            iCF = ('iCF','sum'),
+            iSCF = ('iSCF','sum'),
+            iHDCF = ('iHDCF','sum'),
+            Hits = ('Hits','sum'),
+            Shots_Blocked = ('Shots Blocked','sum'),
+            TOI_pp = ('TOI_pp','sum'),
+            Total_Points_pp = ('Total Points_pp','sum'),
+            TOI_pp_team = ('pp_toi','sum'))#.reset_index()
+
+
+        players_games_og_all_summary['1A_percent'] = (players_games_og_all_summary.First_Assists / players_games_og_all_summary.Assists).round(3)
+        players_games_og_all_summary['PP%'] = (players_games_og_all_summary.TOI_pp / players_games_og_all_summary.TOI_pp_team).round(3)
+        players_games_og_all_summary['G-ixG'] = players_games_og_all_summary.Goals - players_games_og_all_summary.ixG
+        players_games_og_all_summary['S+H+B'] = players_games_og_all_summary.Shots + players_games_og_all_summary.Hits + players_games_og_all_summary.Shots_Blocked
+        players_games_og_all_summary.TOI = players_games_og_all_summary.TOI.round(2)
+        
+        players_games_og_all_summary['1A_percent'] = [f'{str(round(x*100,1))}%' if not math.isnan(x) else '' for x in players_games_og_all_summary['1A_percent']]
+        players_games_og_all_summary['PP%'] = [f'{str(round(x*100,1))}%' if not math.isnan(x) else '' for x in players_games_og_all_summary['PP%']]
+
+        players_games_og_all_summary[['Goals', 'ixG', 'G-ixG','Assists', 
+                              'First_Assists', 'Total_Points','Total_Points_pp','iCF','iSCF', 
+                              'Shots','Hits', 'Shots_Blocked', 'S+H+B', ]] = players_games_og_all_summary[['Goals', 'ixG', 'G-ixG','Assists', 
+                                                                                                            'First_Assists', 'Total_Points','Total_Points_pp','iCF','iSCF', 
+                                                                                                            'Shots','Hits', 'Shots_Blocked', 'S+H+B']].divide(players_games_og_all_summary.TOI/60,axis=0).round(2)
 
 
+        players_games_og_all_summary['TOI/GP'] = players_games_og_all_summary.TOI / players_games_og_all_summary.GP
 
-            fig.set_facecolor('#ffffff')
-            ax.set(xlim=(0,max([team_schedule_url_merge[x].team_game.max() for x in range(len(team_schedule_url_merge))])))
-            ax.set(ylim=(0,max([team_schedule_url_merge[x].stat.max() for x in range(len(team_schedule_url_merge))])))
+        output_df = players_games_og_all_summary.reset_index(drop=False)[['Player', 'Team', 'pos',  'GP', 'TOI', 'TOI/GP','Goals',
+                                                                         'Assists', 'Total_Points','Total_Points_pp','iCF','iSCF', 'Shots','Hits', 'Shots_Blocked', 'S+H+B', 
+                                                                          '1A_percent', 'PP%']]
 
-            ax.legend_.remove()
 
+        output_df.columns = ['Player', 'Team', 'Pos', 'GP', 'TOI','TOI/GP', 'Goals/60','Assists/60', 'Points/60','PPP/60','iCF/60','iSCF/60', 'Shots/60','Hits/60', 'Blocks/60', 'S+H+B/60', 
+                                                                          '1A%', 'PP%']
 
 
-            if per_game == False:
-                fig.suptitle(f'{rookie}{team_select_title}{position_select_title}{stat} Race',y=.98,fontsize=32,color='black',**cgfont)
-                ax.set_ylabel(stat,fontsize=20,color='black',**cgfont)
-            # else:
-            # fig.suptitle(stat+' Per Game, All Situations',y=.99,fontsize=48,color='black',**cgfont)
-            # ax.set_ylabel(stat+"/GP",fontsize=20,color='black',**cgfont)
 
 
 
-            ax.set_title(str(current_season)[0:4]+'-'+str(start_season)[-4:]+' Season',y=1.01,fontsize=18,color='black',**cgfont,x=0,ha='left')
-            ax.set_xlabel('Team Game',fontsize=20,color='black',**cgfont)
-            ax.tick_params(axis="x", labelsize=24,colors='black')
-            ax.set_facecolor('#ffffff')
-            ax.xaxis.set_major_locator(MaxNLocator(integer=True))
-            ax.tick_params(axis="y", labelsize=24,colors='black')
-            ax.yaxis.set_major_locator(MaxNLocator(integer=True))
+        if input.gridstyle():
+            return render.DataGrid(
+                output_df,
+                row_selection_mode=input.selection_mode(),
+                height=height,
+                width='fit-content',
+                filters=input.filters(),
+            )
+        else:
+            return render.DataTable(
+                output_df,
+                row_selection_mode=input.selection_mode(),
+                height=height,
+                width='fit-content',
+                filters=input.filters(),
+            )
 
-            fig.text(x=0.025,y=0.01,s="Created By: @TJStats",color='black', fontsize=20, horizontalalignment='left',**cgfont)
-            fig.text(x=0.975,y=0.01,s="Data: Natural Stat Trick",color='black', fontsize=20, horizontalalignment='right',**cgfont)
-            fig.text(x=.975,y=0.92,s='Date: '+input.date().strftime('%B %d, %Y'),color='black', fontsize=18, horizontalalignment='right',**cgfont)
 
-            ax.legend(prop=font,bbox_to_anchor=(0.01, 0.99),loc='upper left',framealpha=1,frameon=True)
-            plt.tight_layout()
-            #fig.savefig('gif_race/'+stat+rookie+str(date_range_list[k].date())+'.png', facecolor=fig.get_facecolor(), edgecolor='none',bbox_inches='tight',dpi=100)
-            #plt.close()
-            #fig.legend(prop=font,loc='best',framealpha=1,frameon=True)
 
-app = App(app_ui, server)
+app = App(app_ui, server)