Upload 6 files

app.py

@@ -19,6 +19,7 @@ import seaborn as sns
 from functions.pitch_summary_functions import *
 from shiny import App, reactive, ui, render
 from shiny.ui import h2, tags
+from shiny import req
 
 colour_palette = ['#FFB000','#648FFF','#785EF0',
                   '#DC267F','#FE6100','#3D1EB2','#894D80','#16AA02','#B5592B','#A3C1ED']
@@ -52,6 +53,11 @@ split_dict =  {'all':'All',
                'left':'LHH',
                'right':'RHH'}
 
+split_dict_title =  {'all':'',
+               'left':' - vs LHH',
+               'right':' - vs RHH'}
+
+
 split_dict_hand =  {'all':['L','R'],
                'left':['L'],
                'right':['R']}
@@ -110,33 +116,55 @@ from shiny.ui import h2, tags
 app_ui = ui.page_sidebar(
     ui.sidebar(
         # Row for selecting season and level
+        ui.row(ui.markdown("### Select Pitcher 1")),
         ui.row(
-            ui.column(4, ui.input_select('year_input', 'Select Season', year_list, selected=2024)),
-            ui.column(4, ui.input_select('level_input', 'Select Level', level_dict)),
-            ui.column(4, ui.input_select('type_input', 'Select Type', type_dict,selected='R'))
+            ui.column(4, ui.input_select('year_input_1', 'Season', year_list, selected=2024)),
+            ui.column(4, ui.input_select('level_input_1', 'Level', level_dict)),
+            ui.column(4, ui.input_select('type_input_1', 'Type', type_dict,selected='R'))
         ),
         # Row for the action button to get player list
-        ui.row(ui.input_action_button("player_button", "Get Player List", class_="btn-primary")),
+        ui.row(ui.input_action_button("player_button_1", "Get Player List", class_="btn-primary"),
+),
+                         
         # Row for selecting the player
-        ui.row(ui.column(12, ui.output_ui('player_select_ui', 'Select Player'))),
+        ui.row(ui.column(8, ui.output_ui('player_select_ui_1', 'Select Player')),
+                ui.column(4, ui.input_select('split_id_1', 'Select Split', split_dict, multiple=False))    
+                       
+               
+               ),
         # Row for selecting the date range
-        ui.row(ui.column(12, ui.output_ui('date_id', 'Select Date'))),
-
-        # Rows for selecting plots and split options
+        ui.row(ui.column(12, ui.output_ui('date_id_1', 'Select Date'))),
         ui.row(
-            ui.column(4, ui.input_select('plot_id_1', 'Plot Left', function_dict, multiple=False, selected='velocity_kdes')),
-            ui.column(4, ui.input_select('plot_id_2', 'Plot Middle', function_dict, multiple=False, selected='tj_stuff_roling')),
-            ui.column(4, ui.input_select('plot_id_3', 'Plot Right', function_dict, multiple=False, selected='break_plot'))
+            ui.column(6, ui.input_switch("switch_1", "Custom Team?", False)),
+            ui.column(6, ui.input_select('logo_select_1', 'Select Custom Logo', image_dict_flip, multiple=False))
         ),
+
+
+        # Row for selecting season and level
+        ui.row(ui.markdown("### Select Pitcher 2")),
         ui.row(
-            ui.column(6, ui.input_select('split_id', 'Select Split', split_dict, multiple=False)),
-            ui.column(6, ui.input_numeric('rolling_window', 'Rolling Window (for tjStuff+ Plot)', min=1, value=50))
+            ui.column(4, ui.input_select('year_input_2', 'Season', year_list, selected=2024)),
+            ui.column(4, ui.input_select('level_input_2', 'Level', level_dict)),
+            ui.column(4, ui.input_select('type_input_2', 'Type', type_dict,selected='R'))
         ),
+        # Row for the action button to get player list
+        ui.row(ui.input_action_button("player_button_2", "Get Player List", class_="btn-primary"),
+),
+                         
+        # Row for selecting the player
+        ui.row(ui.column(8, ui.output_ui('player_select_ui_2', 'Select Player')),
+                ui.column(4, ui.input_select('split_id_2', 'Select Split', split_dict, multiple=False))    
+                       
+               
+               ),
+        # Row for selecting the date range
+        ui.row(ui.column(12, ui.output_ui('date_id_2', 'Select Date'))),
+
         ui.row(
-            ui.column(6, ui.input_switch("switch", "Custom Team?", False)),
-            ui.column(6, ui.input_select('logo_select', 'Select Custom Logo', image_dict_flip, multiple=False))
+            ui.column(6, ui.input_switch("switch_2", "Custom Team?", False)),
+            ui.column(6, ui.input_select('logo_select_2', 'Select Custom Logo', image_dict_flip, multiple=False))
         ),
-        
+
         # Row for the action button to generate plot
         ui.row(ui.input_action_button("generate_plot", "Generate Plot", class_="btn-primary")),
         width="400px"  # Added this parameter to control sidebar width
@@ -144,38 +172,74 @@ app_ui = ui.page_sidebar(
             
     # Main content area with tabs (placed directly in page_sidebar)
     ui.navset_tab(
-        ui.nav_panel("Pitching Summary",
+        ui.nav_panel("Full Compare",
                ui.output_text("status"),
-               ui.output_plot('plot', width='2100px', height='2100px')
-        ),
+               ui.output_plot('plot', width='2100px', height='2100px')),
+        ui.nav_panel("Break Plots",
+               ui.output_text("status_break"),
+               ui.output_plot('plot_break', width='2100px', height='1300px')),
+        ui.nav_panel("Tables",
+               ui.output_text("status_table"),
+               ui.output_plot('plot_table', width='2100px', height='1300px')),
+        id="tabset_id",
+                              
+               
+               
+               ),
     )
-)
+
 
 
 def server(input, output, session):
 
     @reactive.calc
-    @reactive.event(input.pitcher_id, input.date_id,input.split_id)
-    def cached_data():
-
-        year_input = int(input.year_input())
-        sport_id = int(input.level_input())
-        player_input = int(input.pitcher_id())
-        start_date = str(input.date_id()[0])
-        end_date = str(input.date_id()[1])
+    @reactive.event(input.pitcher_id_1, input.date_id_1,input.split_id_1)
+    def cached_data_1():
+
+        year_input = int(input.year_input_1())
+        sport_id = int(input.level_input_1())
+        player_input = int(input.pitcher_id_1())
+        start_date = str(input.date_id_1()[0])
+        end_date = str(input.date_id_1()[1])
         # Simulate an expensive data operation
         game_list  = scrape.get_player_games_list(sport_id = sport_id,
                                                 season = year_input, 
                                                 player_id = player_input,
                                                 start_date = start_date,
                                                 end_date = end_date,
-                                                game_type = [input.type_input()])
+                                                game_type = [input.type_input_1()])
 
         data_list = scrape.get_data(game_list_input = game_list[:])
         df = (stuff_apply.stuff_apply(fe.feature_engineering(update.update(scrape.get_data_df(data_list = data_list).filter(
                             (pl.col("pitcher_id") == player_input)&
                             (pl.col("is_pitch") == True)&
-                            (pl.col('batter_hand').is_in(split_dict_hand[input.split_id()]))
+                            (pl.col('batter_hand').is_in(split_dict_hand[input.split_id_1()]))
+
+                            )))).with_columns(
+                pl.col('pitch_type').count().over('pitch_type').alias('pitch_count')
+            ))
+        return df
+
+    def cached_data_2():
+
+        year_input = int(input.year_input_2())
+        sport_id = int(input.level_input_2())
+        player_input = int(input.pitcher_id_2())
+        start_date = str(input.date_id_2()[0])
+        end_date = str(input.date_id_2()[1])
+        # Simulate an expensive data operation
+        game_list  = scrape.get_player_games_list(sport_id = sport_id,
+                                                season = year_input, 
+                                                player_id = player_input,
+                                                start_date = start_date,
+                                                end_date = end_date,
+                                                game_type = [input.type_input_2()])
+
+        data_list = scrape.get_data(game_list_input = game_list[:])
+        df = (stuff_apply.stuff_apply(fe.feature_engineering(update.update(scrape.get_data_df(data_list = data_list).filter(
+                            (pl.col("pitcher_id") == player_input)&
+                            (pl.col("is_pitch") == True)&
+                            (pl.col('batter_hand').is_in(split_dict_hand[input.split_id_2()]))
 
                             )))).with_columns(
                 pl.col('pitch_type').count().over('pitch_type').alias('pitch_count')
@@ -183,27 +247,54 @@ def server(input, output, session):
         return df
 
     @render.ui
-    @reactive.event(input.player_button, input.year_input, input.level_input, input.type_input,ignore_none=False)
-    def player_select_ui():
+    @reactive.event(input.player_button_1, input.year_input_1, input.level_input_1, input.type_input_1,ignore_none=False)
+    def player_select_ui_1():
+        
         # Get the list of pitchers for the selected level and season
-        df_pitcher_info = scrape.get_players(sport_id=int(input.level_input()), season=int(input.year_input()), game_type = [input.type_input()]).filter(
+        df_pitcher_info = scrape.get_players(sport_id=int(input.level_input_1()), season=int(input.year_input_1()), game_type = [input.type_input_1()]).filter(
             pl.col("position").is_in(['P','TWP'])).sort("name")
         
         # Create a dictionary of pitcher IDs and names
         pitcher_dict = dict(zip(df_pitcher_info['player_id'], df_pitcher_info['name']))
         
         # Return a select input for choosing a pitcher
-        return ui.input_select("pitcher_id", "Select Pitcher", pitcher_dict, selectize=True)
+        return ui.input_select("pitcher_id_1", "Select Pitcher", pitcher_dict, selectize=True)
+
+
+    @render.ui
+    @reactive.event(input.player_button_2, input.year_input_2, input.level_input_2, input.type_input_2,ignore_none=False)
+    def player_select_ui_2():
+        # Get the list of pitchers for the selected level and season
+        df_pitcher_info = scrape.get_players(sport_id=int(input.level_input_2()), season=int(input.year_input_2()), game_type = [input.type_input_2()]).filter(
+            pl.col("position").is_in(['P','TWP'])).sort("name")
+        
+        # Create a dictionary of pitcher IDs and names
+        pitcher_dict = dict(zip(df_pitcher_info['player_id'], df_pitcher_info['name']))
+        
+        # Return a select input for choosing a pitcher
+        return ui.input_select("pitcher_id_2", "Select Pitcher", pitcher_dict, selectize=True)
+
+    @render.ui
+    @reactive.event(input.player_button_1, input.year_input_1, ignore_none=False)
+    def date_id_1():
+        # Create a date range input for selecting the date range within the selected year
+        return ui.input_date_range("date_id_1", "Select Date Range",
+                                   start=f"{int(input.year_input_1())}-01-01",
+                                   end=f"{int(input.year_input_1())}-12-31",
+                                   min=f"{int(input.year_input_1())}-01-01",
+                                    max=f"{int(input.year_input_1())}-12-31")
 
     @render.ui
-    @reactive.event(input.player_button, ignore_none=False)
-    def date_id():
+    @reactive.event(input.player_button_1, input.year_input_1, ignore_none=False)
+    def date_id_2():
         # Create a date range input for selecting the date range within the selected year
-        return ui.input_date_range("date_id", "Select Date Range",
-                                   start=f"{int(input.year_input())}-01-01",
-                                   end=f"{int(input.year_input())}-12-31",
-                                   min=f"{int(input.year_input())}-01-01",
-                                    max=f"{int(input.year_input())}-12-31")
+        return ui.input_date_range("date_id_2", "Select Date Range",
+                                   start=f"{int(input.year_input_2())}-01-01",
+                                   end=f"{int(input.year_input_2())}-12-31",
+                                   min=f"{int(input.year_input_2())}-01-01",
+                                    max=f"{int(input.year_input_2())}-12-31")    
+
+
     @output
     @render.text
     def status():
@@ -211,27 +302,59 @@ def server(input, output, session):
         if input.generate == 0:
             return ""
         return ""   
-    
+
+    @output
+    @render.text
+    def status_break():
+        # Only show status when generating
+        if input.generate == 0:
+            return ""
+        return ""   
+    @output
+    @render.text
+    def status_table():
+        # Only show status when generating
+        if input.generate == 0:
+            return ""
+        return ""   
+
     @output
     @render.plot
     @reactive.event(input.generate_plot, ignore_none=False)   
-    def plot():     
+    def plot():    
+        req(input.generate_plot())
         # Show progress/loading notification
         with ui.Progress(min=0, max=1) as p:
+
+
             p.set(message="Generating plot", detail="This may take a while...")
 
             
             p.set(0.3, "Gathering data...")
-            year_input = int(input.year_input())
-            sport_id = int(input.level_input())
-            player_input = int(input.pitcher_id())
-            start_date = str(input.date_id()[0])
-            end_date = str(input.date_id()[1])
+            year_input = int(input.year_input_1())
+            sport_id = int(input.level_input_1())
+            player_input = int(input.pitcher_id_1())
+            start_date = str(input.date_id_1()[0])
+            end_date = str(input.date_id_1()[1])
 
             print(year_input, sport_id, player_input, start_date, end_date)
 
-            df = cached_data()
+            year_input_2 = int(input.year_input_2())
+            sport_id_2 = int(input.level_input_2())
+            player_input_2 = int(input.pitcher_id_2())
+            start_date_2 = str(input.date_id_2()[0])
+            end_date_2 = str(input.date_id_2()[1])
+
+            print(year_input_2, sport_id_2, player_input_2, start_date_2, end_date_2)
+
+
+
+            df = cached_data_1()
+            print(df)
+            df_2 = cached_data_2()
+            print(df_2)
             df = df.clone()
+            df_2 = df_2.clone()
 
             p.set(0.6, "Creating plot...")
 
@@ -243,28 +366,30 @@ def server(input, output, session):
             sns.set_theme(style="whitegrid", palette=colour_palette)
             print('this is the one plot')
 
-            gs = gridspec.GridSpec(6, 8,
-                                height_ratios=[5,20,12,36,36,7],
-                                width_ratios=[4,18,18,18,18,18,18,4])
+            gs = gridspec.GridSpec(6, 12,
+                                height_ratios=[1,10,40,25,25,5],
+                                width_ratios=[3,3,10,24,10,3,3,10,24,10,3,3])
+
 
+            gs.update(hspace=0.15, wspace=0.15)
 
-            gs.update(hspace=0.2, wspace=0.5)
+            ax_headshot_1 = fig.add_subplot(gs[1,2])
+            ax_bio_1 = fig.add_subplot(gs[1,3])
+            ax_logo_1 = fig.add_subplot(gs[1,4])
+            ax_break_1 = fig.add_subplot(gs[2,1:6])
+            ax_table_1 = fig.add_subplot(gs[3,1:11])
 
-            # Define the positions of each subplot in the grid
-            ax_headshot = fig.add_subplot(gs[1,1:3])
-            ax_bio = fig.add_subplot(gs[1,3:5])
-            ax_logo = fig.add_subplot(gs[1,5:7])
 
-            ax_season_table = fig.add_subplot(gs[2,1:7])
+            ax_headshot_2 = fig.add_subplot(gs[1,7])
+            ax_bio_2 = fig.add_subplot(gs[1,8])
+            ax_logo_2 = fig.add_subplot(gs[1,9])
+            ax_break_2 = fig.add_subplot(gs[2,6:11])
+            ax_table_2 = fig.add_subplot(gs[4,1:11])
 
-            ax_plot_1 = fig.add_subplot(gs[3,1:3])
-            ax_plot_2 = fig.add_subplot(gs[3,3:5])
-            ax_plot_3 = fig.add_subplot(gs[3,5:7])
 
-            ax_table = fig.add_subplot(gs[4,1:7])
 
-            ax_footer = fig.add_subplot(gs[-1,1:7])
-            ax_header = fig.add_subplot(gs[0,1:7])
+            ax_footer = fig.add_subplot(gs[-1,1:11])
+            ax_header = fig.add_subplot(gs[0,1:11])
             ax_left = fig.add_subplot(gs[:,0])
             ax_right = fig.add_subplot(gs[:,-1])
 
@@ -277,15 +402,55 @@ def server(input, output, session):
             sns.set_theme(style="whitegrid", palette=colour_palette)
             fig.set_facecolor('white')
 
+            # df_teams = scrape.get_teams()
+
+            player_headshot(player_input=player_input, ax=ax_headshot_1,sport_id=sport_id,season=year_input)
+            player_bio(pitcher_id=player_input, ax=ax_bio_1,sport_id=sport_id,year_input=year_input,
+                       df=df,split=input.split_id_1(),game_type=input.type_input_1())
+            
             df_teams = scrape.get_teams()
+            if input.switch_1():
 
-            player_headshot(player_input=player_input, ax=ax_headshot,sport_id=sport_id,season=year_input)
-            player_bio(pitcher_id=player_input, ax=ax_bio,sport_id=sport_id,year_input=year_input)
+                # Get the logo URL from the image dictionary using the team abbreviation
+                logo_url = input.logo_select_1()
+        
+                # Send a GET request to the logo URL
+                response = requests.get(logo_url)
+        
+                # Open the image from the response content
+                img = Image.open(BytesIO(response.content))
+        
+                # Display the image on the axis
+                ax_logo_1.set_xlim(0, 1)
+                ax_logo_1.set_ylim(0, 1)
+                ax_logo_1.imshow(img, extent=[0, 1, 0, 1], origin='upper')
+        
+                # Turn off the axis
+                ax_logo_1.axis('off')
+            
+            else:
+                plot_logo(pitcher_id=player_input, ax=ax_logo_1, df_team=df_teams,df_players=scrape.get_players(sport_id,year_input))
 
-            if input.switch():
+            break_plot(df = df,ax=ax_break_1) 
+            summary_table(df=df,
+                        ax=ax_table_1)
+            ax_table_1.text(x=0.5,y=0.83,s=f'{df["pitcher_name"][0]} - {year_input} - {level_dict[str(sport_id)]} - {type_dict[input.type_input_1()]}{split_dict_title[input.split_id_1()]}', 
+                    fontsize=30, ha='center', va='bottom',fontstyle='italic')  
+# level_dict
+# split_dict
+# type_dict
+
+#####################
+
+            player_headshot(player_input=player_input_2, ax=ax_headshot_2,sport_id=sport_id_2,season=year_input_2)
+            player_bio(pitcher_id=player_input_2, ax=ax_bio_2,sport_id=sport_id_2,year_input=year_input_2,
+                       df=df_2,split=input.split_id_2(),game_type=input.type_input_2())
+            
+            # df_teams = scrape.get_teams()
+            if input.switch_2():
 
                 # Get the logo URL from the image dictionary using the team abbreviation
-                logo_url = input.logo_select()
+                logo_url = input.logo_select_2()
         
                 # Send a GET request to the logo URL
                 response = requests.get(logo_url)
@@ -294,63 +459,378 @@ def server(input, output, session):
                 img = Image.open(BytesIO(response.content))
         
                 # Display the image on the axis
-                ax_logo.set_xlim(0, 1.3)
-                ax_logo.set_ylim(0, 1)
-                ax_logo.imshow(img, extent=[0.3, 1.3, 0, 1], origin='upper')
+                ax_logo_2.set_xlim(0, 1)
+                ax_logo_2.set_ylim(0, 1)
+                ax_logo_2.imshow(img, extent=[0, 1, 0, 1], origin='upper')
         
                 # Turn off the axis
-                ax_logo.axis('off')
+                ax_logo_2.axis('off')
             
             else:
-                plot_logo(pitcher_id=player_input, ax=ax_logo, df_team=df_teams,df_players=scrape.get_players(sport_id,year_input))
-
-            stat_summary_table(df=df,
-                            ax=ax_season_table,
-                            player_input=player_input,
-                            split=input.split_id(),
-                            sport_id=sport_id,
-                            game_type=[input.type_input()])
-
-            # break_plot(df=df_plot,ax=ax2) 
-            for x,y,z in zip([input.plot_id_1(),input.plot_id_2(),input.plot_id_3()],[ax_plot_1,ax_plot_2,ax_plot_3],[1,3,5]):
-                if x == 'velocity_kdes':
-                            velocity_kdes(df,
-                            ax=y,
-                            gs=gs,
-                            gs_x=[3,4],
-                            gs_y=[z,z+2],
-                            fig=fig)
-                if x == 'tj_stuff_roling':
-                    tj_stuff_roling(df=df,
-                                window=int(input.rolling_window()),
-                                ax=y)
-                    
-                if x == 'tj_stuff_roling_game':
-                    tj_stuff_roling_game(df=df, 
-                                        window=int(input.rolling_window()),
-                                        ax=y)
-
-                if x == 'break_plot':
-                    break_plot(df = df,ax=y) 
-
-                if x == 'location_plot_lhb':
-                    location_plot(df = df,ax=y,hand='L')
-
-                if x == 'location_plot_rhb':
-                    location_plot(df = df,ax=y,hand='R')
+                plot_logo(pitcher_id=player_input_2, ax=ax_logo_2, df_team=df_teams,df_players=scrape.get_players(sport_id_2,year_input_2))
 
-            summary_table(df=df,
-                        ax=ax_table)
 
+            break_plot(df = df_2,ax=ax_break_2) 
+            summary_table(df=df_2,
+                        ax=ax_table_2)
+            ax_table_2.text(x=0.5,y=0.83,s=f'{df_2["pitcher_name"][0]} - {year_input_2} - {level_dict[str(sport_id_2)]} - {type_dict[input.type_input_2()]}{split_dict_title[input.split_id_2()]}', 
+                    fontsize=30, ha='center', va='bottom',fontstyle='italic')  
+
+#########################
             plot_footer(ax_footer)   
 
             fig.subplots_adjust(left=0.01, right=0.99, top=0.99, bottom=0.01)
 
+            # Draw a line halfway down the figure, starting from the top middle and going to the center
+            line = plt.Line2D([0.5, 0.5], [0.55, 0.95], transform=fig.transFigure, color="grey",alpha=0.4, linewidth=2)
+            fig.add_artist(line)
+    
+    @output
+    @render.plot
+    @reactive.event(input.generate_plot, ignore_none=False)   
+    def plot_break():  
+        req(input.generate_plot())
+        # Show progress/loading notification
+        with ui.Progress(min=0, max=1) as p:
+
+
+            p.set(message="Generating plot", detail="This may take a while...")
+
+            
+            p.set(0.3, "Gathering data...")
+            year_input = int(input.year_input_1())
+            sport_id = int(input.level_input_1())
+            player_input = int(input.pitcher_id_1())
+            start_date = str(input.date_id_1()[0])
+            end_date = str(input.date_id_1()[1])
+
+            print(year_input, sport_id, player_input, start_date, end_date)
+
+            year_input_2 = int(input.year_input_2())
+            sport_id_2 = int(input.level_input_2())
+            player_input_2 = int(input.pitcher_id_2())
+            start_date_2 = str(input.date_id_2()[0])
+            end_date_2 = str(input.date_id_2()[1])
+
+            print(year_input_2, sport_id_2, player_input_2, start_date_2, end_date_2)
+
+
+
+            df = cached_data_1()
+            print(df)
+            df_2 = cached_data_2()
+            print(df_2)
+            df = df.clone()
+            df_2 = df_2.clone()
+
+            p.set(0.6, "Creating plot...")
+
+  
+            #plt.rcParams["figure.figsize"] = [10,10]
+            fig = plt.figure(figsize=(26,26))
+            plt.rcParams.update({'figure.autolayout': True})
+            fig.set_facecolor('white')
+            sns.set_theme(style="whitegrid", palette=colour_palette)
+            print('this is the one plot')
+
+            gs = gridspec.GridSpec(4, 12,
+                                height_ratios=[1,10,40,10],
+                                width_ratios=[3,3,10,24,10,3,3,10,24,10,3,3])
+
+
+            gs.update(hspace=0.15, wspace=0.15)
+
+            ax_headshot_1 = fig.add_subplot(gs[1,2])
+            ax_bio_1 = fig.add_subplot(gs[1,3])
+            ax_logo_1 = fig.add_subplot(gs[1,4])
+            ax_break_1 = fig.add_subplot(gs[2,1:6])
+            # ax_table_1 = fig.add_subplot(gs[3,1:11])
+
+
+            ax_headshot_2 = fig.add_subplot(gs[1,7])
+            ax_bio_2 = fig.add_subplot(gs[1,8])
+            ax_logo_2 = fig.add_subplot(gs[1,9])
+            ax_break_2 = fig.add_subplot(gs[2,6:11])
+            # ax_table_2 = fig.add_subplot(gs[4,1:11])
+
+
+
+            ax_footer = fig.add_subplot(gs[-1,1:11])
+            ax_header = fig.add_subplot(gs[0,1:11])
+            ax_left = fig.add_subplot(gs[:,0])
+            ax_right = fig.add_subplot(gs[:,-1])
+
+            # Hide axes for footer, header, left, and right
+            ax_footer.axis('off')
+            ax_header.axis('off')
+            ax_left.axis('off')
+            ax_right.axis('off')
+
+            sns.set_theme(style="whitegrid", palette=colour_palette)
+            fig.set_facecolor('white')
 
+            # df_teams = scrape.get_teams()
+
+            player_headshot(player_input=player_input, ax=ax_headshot_1,sport_id=sport_id,season=year_input)
+            player_bio(pitcher_id=player_input, ax=ax_bio_1,sport_id=sport_id,year_input=year_input,
+                       df=df,split=input.split_id_1(),game_type=input.type_input_1())
+            
+            df_teams = scrape.get_teams()
+            if input.switch_1():
+
+                # Get the logo URL from the image dictionary using the team abbreviation
+                logo_url = input.logo_select_1()
+        
+                # Send a GET request to the logo URL
+                response = requests.get(logo_url)
+        
+                # Open the image from the response content
+                img = Image.open(BytesIO(response.content))
+        
+                # Display the image on the axis
+                ax_logo_1.set_xlim(0, 1)
+                ax_logo_1.set_ylim(0, 1)
+                ax_logo_1.imshow(img, extent=[0, 1, 0, 1], origin='upper')
+        
+                # Turn off the axis
+                ax_logo_1.axis('off')
+            
+            else:
+                plot_logo(pitcher_id=player_input, ax=ax_logo_1, df_team=df_teams,df_players=scrape.get_players(sport_id,year_input))
+
+            break_plot(df = df,ax=ax_break_1) 
+
+
+#####################
+
+            player_headshot(player_input=player_input_2, ax=ax_headshot_2,sport_id=sport_id_2,season=year_input_2)
+            player_bio(pitcher_id=player_input_2, ax=ax_bio_2,sport_id=sport_id_2,year_input=year_input_2,
+                       df=df_2,split=input.split_id_2(),game_type=input.type_input_2())
+            
+            # df_teams = scrape.get_teams()
+            if input.switch_2():
+
+                # Get the logo URL from the image dictionary using the team abbreviation
+                logo_url = input.logo_select_2()
+        
+                # Send a GET request to the logo URL
+                response = requests.get(logo_url)
+        
+                # Open the image from the response content
+                img = Image.open(BytesIO(response.content))
+        
+                # Display the image on the axis
+                ax_logo_2.set_xlim(0, 1)
+                ax_logo_2.set_ylim(0, 1)
+                ax_logo_2.imshow(img, extent=[0, 1, 0, 1], origin='upper')
+        
+                # Turn off the axis
+                ax_logo_2.axis('off')
+            
+            else:
+                plot_logo(pitcher_id=player_input_2, ax=ax_logo_2, df_team=df_teams,df_players=scrape.get_players(sport_id_2,year_input_2))
+
+
+            break_plot(df = df_2,ax=ax_break_2) 
+
+#########################
+            plot_footer_break(ax_footer)   
+
+            fig.subplots_adjust(left=0.01, right=0.99, top=0.99, bottom=0.01)
+
+            # Draw a line halfway down the figure, starting from the top middle and going to the center
+            line = plt.Line2D([0.5, 0.5], [0.15, 0.95], transform=fig.transFigure, color="grey",alpha=0.4, linewidth=2)
+            fig.add_artist(line)
     
 
-app = App(app_ui, server)
+        df_legend = pl.concat([df, df_2]) 
+            # # Create legend for pitch types
+        items_in_order = (df_legend.sort("pitch_count", descending=True)['pitch_type'].unique(maintain_order=True).to_numpy())
+        colour_pitches = [dict_colour[x] for x in items_in_order]
+        label = [dict_pitch[x] for x in items_in_order]
+        handles = [plt.scatter([], [], color=color, marker='o', s=100) for color in colour_pitches]
+
+        if len(label) > 10:
+            ax_footer.legend(handles, label, bbox_to_anchor=(0.1, 0.2, 0.8, 0.3), ncol=5,
+                     fancybox=True, loc='lower center', fontsize=16, framealpha=1.0, markerscale=1.7, prop={'family': 'calibi', 'size': 16})
+        if len(label) > 5:
+            ax_footer.legend(handles, label, bbox_to_anchor=(0.1, 0.2, 0.8, 0.2), ncol=5,
+                     fancybox=True, loc='lower center', fontsize=16, framealpha=1.0, markerscale=1.7, prop={'family': 'calibi', 'size': 16})
+        else:
+            ax_footer.legend(handles, label, bbox_to_anchor=(0.1, 0.2, 0.8, 0.14), ncol=5,
+                    fancybox=True, loc='lower center', fontsize=20, framealpha=1.0, markerscale=2, prop={'family': 'calibi', 'size': 20})
+        ax_footer.axis('off')
+
+
+    @output
+    @render.plot
+    @reactive.event(input.generate_plot, ignore_none=False)   
+    def plot_table():     
+        req(input.generate_plot())
+        # Show progress/loading notification
+        with ui.Progress(min=0, max=1) as p:
+
+
+            p.set(message="Generating plot", detail="This may take a while...")
+
+            
+            p.set(0.3, "Gathering data...")
+            year_input = int(input.year_input_1())
+            sport_id = int(input.level_input_1())
+            player_input = int(input.pitcher_id_1())
+            start_date = str(input.date_id_1()[0])
+            end_date = str(input.date_id_1()[1])
 
+            print(year_input, sport_id, player_input, start_date, end_date)
+
+            year_input_2 = int(input.year_input_2())
+            sport_id_2 = int(input.level_input_2())
+            player_input_2 = int(input.pitcher_id_2())
+            start_date_2 = str(input.date_id_2()[0])
+            end_date_2 = str(input.date_id_2()[1])
+
+            print(year_input_2, sport_id_2, player_input_2, start_date_2, end_date_2)
+
+
+
+            df = cached_data_1()
+            print(df)
+            df_2 = cached_data_2()
+            print(df_2)
+            df = df.clone()
+            df_2 = df_2.clone()
+
+            p.set(0.6, "Creating plot...")
+
+  
+            #plt.rcParams["figure.figsize"] = [10,10]
+            fig = plt.figure(figsize=(26,26))
+            plt.rcParams.update({'figure.autolayout': True})
+            fig.set_facecolor('white')
+            sns.set_theme(style="whitegrid", palette=colour_palette)
+            print('this is the one plot')
+
+            gs = gridspec.GridSpec(4, 12,
+                                height_ratios=[1,25,25,5],
+                                width_ratios=[3,3,10,24,10,3,3,10,24,10,3,3])
+
+
+            gs.update(hspace=0.15, wspace=0.15)
+
+            # ax_headshot_1 = fig.add_subplot(gs[1,2])
+            # ax_bio_1 = fig.add_subplot(gs[1,3])
+            # ax_logo_1 = fig.add_subplot(gs[1,4])
+            # ax_break_1 = fig.add_subplot(gs[2,1:6])
+            ax_table_1 = fig.add_subplot(gs[1,1:11])
+
+
+            # ax_headshot_2 = fig.add_subplot(gs[1,7])
+            # ax_bio_2 = fig.add_subplot(gs[1,8])
+            # ax_logo_2 = fig.add_subplot(gs[1,9])
+            # ax_break_2 = fig.add_subplot(gs[2,6:11])
+            ax_table_2 = fig.add_subplot(gs[2,1:11])
+
+
+
+            ax_footer = fig.add_subplot(gs[-1,1:11])
+            ax_header = fig.add_subplot(gs[0,1:11])
+            ax_left = fig.add_subplot(gs[:,0])
+            ax_right = fig.add_subplot(gs[:,-1])
+
+            # Hide axes for footer, header, left, and right
+            ax_footer.axis('off')
+            ax_header.axis('off')
+            ax_left.axis('off')
+            ax_right.axis('off')
+
+            sns.set_theme(style="whitegrid", palette=colour_palette)
+            fig.set_facecolor('white')
+
+            # df_teams = scrape.get_teams()
+
+            # player_headshot(player_input=player_input, ax=ax_headshot_1,sport_id=sport_id,season=year_input)
+            # player_bio(pitcher_id=player_input, ax=ax_bio_1,sport_id=sport_id,year_input=year_input,
+            #            df=df,split=input.split_id_1(),game_type=input.type_input_1())
+            
+            # df_teams = scrape.get_teams()
+            # if input.switch_1():
+
+            #     # Get the logo URL from the image dictionary using the team abbreviation
+            #     logo_url = input.logo_select_1()
+        
+            #     # Send a GET request to the logo URL
+            #     response = requests.get(logo_url)
+        
+            #     # Open the image from the response content
+            #     img = Image.open(BytesIO(response.content))
+        
+            #     # Display the image on the axis
+            #     ax_logo_1.set_xlim(0, 1)
+            #     ax_logo_1.set_ylim(0, 1)
+            #     ax_logo_1.imshow(img, extent=[0, 1, 0, 1], origin='upper')
+        
+            #     # Turn off the axis
+            #     # ax_logo_1.axis('off')
+            
+            # else:
+            #     plot_logo(pitcher_id=player_input, ax=ax_logo_1, df_team=df_teams,df_players=scrape.get_players(sport_id,year_input))
+
+            # break_plot(df = df,ax=ax_break_1) 
+            summary_table(df=df,
+                        ax=ax_table_1)
+            ax_table_1.text(x=0.5,y=0.83,s=f'{df["pitcher_name"][0]} - {year_input} - {level_dict[str(sport_id)]} - {type_dict[input.type_input_1()]}{split_dict_title[input.split_id_1()]}', 
+                    fontsize=30, ha='center', va='bottom',fontstyle='italic')  
+# level_dict
+# split_dict
+# type_dict
+
+#####################
+
+            # player_headshot(player_input=player_input_2, ax=ax_headshot_2,sport_id=sport_id_2,season=year_input_2)
+            # player_bio(pitcher_id=player_input_2, ax=ax_bio_2,sport_id=sport_id_2,year_input=year_input_2,
+            #            df=df_2,split=input.split_id_2(),game_type=input.type_input_2())
+            
+            # # df_teams = scrape.get_teams()
+            # if input.switch_2():
+
+            #     # Get the logo URL from the image dictionary using the team abbreviation
+            #     logo_url = input.logo_select_2()
+        
+            #     # Send a GET request to the logo URL
+            #     response = requests.get(logo_url)
+        
+            #     # Open the image from the response content
+            #     img = Image.open(BytesIO(response.content))
+        
+            #     # Display the image on the axis
+            #     ax_logo_2.set_xlim(0, 1)
+            #     ax_logo_2.set_ylim(0, 1)
+            #     ax_logo_2.imshow(img, extent=[0, 1, 0, 1], origin='upper')
+        
+            #     # Turn off the axis
+            #     ax_logo_2.axis('off')
             
+            # else:
+            #     plot_logo(pitcher_id=player_input_2, ax=ax_logo_2, df_team=df_teams,df_players=scrape.get_players(sport_id_2,year_input_2))
+
+
+            # break_plot(df = df_2,ax=ax_break_2) 
+            summary_table(df=df_2,
+                        ax=ax_table_2)
+            ax_table_2.text(x=0.5,y=0.83,s=f'{df_2["pitcher_name"][0]} - {year_input_2} - {level_dict[str(sport_id_2)]} - {type_dict[input.type_input_2()]}{split_dict_title[input.split_id_2()]}', 
+                    fontsize=30, ha='center', va='bottom',fontstyle='italic')  
+
+#########################
+            plot_footer(ax_footer)   
+
+            fig.subplots_adjust(left=0.01, right=0.99, top=0.99, bottom=0.01)
+
+            # # Draw a line halfway down the figure, starting from the top middle and going to the center
+            # line = plt.Line2D([0.5, 0.5], [0.55, 0.95], transform=fig.transFigure, color="grey",alpha=0.4, linewidth=2)
+            # fig.add_artist(line)
+
+
+
+app = App(app_ui, server)
 
-app = App(app_ui, server)
+        

functions/pitch_summary_functions.py

@@ -662,18 +662,21 @@ def summary_table(df: pl.DataFrame, ax: plt.Axes):
     format_cells(['count_percent', 'zone_percent', 'chase_percent', 'whiff_percent'], '{:,.1%}')
     format_cells(['tj_stuff_plus', 'pitch_grade', 'spin_rate'], '{:,.0f}')
 
-    # Create legend for pitch types
-    items_in_order = (df.sort("pitch_count", descending=True)['pitch_type'].unique(maintain_order=True).to_numpy())
-    colour_pitches = [dict_colour[x] for x in items_in_order]
-    label = [dict_pitch[x] for x in items_in_order]
-    handles = [plt.scatter([], [], color=color, marker='o', s=100) for color in colour_pitches]
-    if len(label) > 5:
-        ax.legend(handles, label, bbox_to_anchor=(0.1, 0.81, 0.8, 0.14), ncol=5,
-                  fancybox=True, loc='lower center', fontsize=16, framealpha=1.0, markerscale=1.7, prop={'family': 'calibi', 'size': 16})
-    else:
-        ax.legend(handles, label, bbox_to_anchor=(0.1, 0.81, 0.8, 0.14), ncol=5,
-                  fancybox=True, loc='lower center', fontsize=20, framealpha=1.0, markerscale=2, prop={'family': 'calibi', 'size': 20})
+    # # Create legend for pitch types
+    # items_in_order = (df.sort("pitch_count", descending=True)['pitch_type'].unique(maintain_order=True).to_numpy())
+    # colour_pitches = [dict_colour[x] for x in items_in_order]
+    # label = [dict_pitch[x] for x in items_in_order]
+    # handles = [plt.scatter([], [], color=color, marker='o', s=100) for color in colour_pitches]
+    # if len(label) > 5:
+    #     ax.legend(handles, label, bbox_to_anchor=(0.1, 0.81, 0.8, 0.14), ncol=5,
+    #               fancybox=True, loc='lower center', fontsize=16, framealpha=1.0, markerscale=1.7, prop={'family': 'calibi', 'size': 16})
+    # else:
+    #     ax.legend(handles, label, bbox_to_anchor=(0.1, 0.81, 0.8, 0.14), ncol=5,
+    #               fancybox=True, loc='lower center', fontsize=20, framealpha=1.0, markerscale=2, prop={'family': 'calibi', 'size': 20})
     ax.axis('off')
+    # ax.set_title(f'{df["pitcher_name"][0]}', fontdict=font_properties_titles)
+    # ax.text(x=0.5,y=0.90,s=f'{df["pitcher_name"][0]}', 
+    #         fontsize=30, ha='center', va='bottom',)
 
 def plot_footer(ax: plt.Axes):
     """
@@ -685,8 +688,8 @@ def plot_footer(ax: plt.Axes):
         The axis to add the footer text to.
     """
     # Add footer text
-    ax.text(0, 1, 'By: @TJStats', ha='left', va='top', fontsize=24)
-    ax.text(0.5, 0.25, 
+    ax.text(0, 1, 'By: Thomas Nestico\n      @TJStats', ha='left', va='top', fontsize=24)
+    ax.text(0.5, 0.15, 
             '''
             Colour Coding Compares to League Average By Pitch
             tjStuff+ calculates the Expected Run Value (xRV) of a pitch regardless of type
@@ -694,7 +697,31 @@ def plot_footer(ax: plt.Axes):
             Pitch Grade scales tjStuff+ to the traditional 20-80 Scouting Scale for a given pitch type
             ''', 
             ha='center', va='bottom', fontsize=12)
-    ax.text(1, 1, 'Data: MLB, Fangraphs\nImages: MLB, ESPN', ha='right', va='top', fontsize=24)
+    ax.text(1, 1, 'Data: MLB\nImages: MLB, ESPN', ha='right', va='top', fontsize=24)
+    ax.axis('off')
+
+
+
+def plot_footer_break(ax: plt.Axes):
+    """
+    Add footer text to the plot.
+
+    Parameters
+    ----------
+    ax : plt.Axes
+        The axis to add the footer text to.
+    """
+    # Add footer text
+    ax.text(0, 0.25, 'By: Thomas Nestico\n      @TJStats', ha='left', va='bottom', fontsize=24)
+    # ax.text(0.5, 0.15, 
+    #         '''
+    #         Colour Coding Compares to League Average By Pitch
+    #         tjStuff+ calculates the Expected Run Value (xRV) of a pitch regardless of type
+    #         tjStuff+ is normally distributed, where 100 is the mean and Standard Deviation is 10
+    #         Pitch Grade scales tjStuff+ to the traditional 20-80 Scouting Scale for a given pitch type
+    #         ''', 
+    #         ha='center', va='bottom', fontsize=12)
+    ax.text(1, 0.25, 'Data: MLB\nImages: MLB, ESPN', ha='right', va='bottom', fontsize=24)
     ax.axis('off')
 
 # Function to get an image from a URL and display it on the given axis
@@ -725,7 +752,7 @@ def player_headshot(player_input: str, ax: plt.Axes, sport_id: int, season: int)
         img = Image.open(BytesIO(response.content))
 
         # Display the image on the axis
-        ax.set_xlim(0, 1.3)
+        ax.set_xlim(0, 1)
         ax.set_ylim(0, 1)
         ax.imshow(img, extent=[0, 1, 0, 1] if sport_id == 1 else [1/6, 5/6, 0, 1], origin='upper')
     except PIL.UnidentifiedImageError:
@@ -735,7 +762,18 @@ def player_headshot(player_input: str, ax: plt.Axes, sport_id: int, season: int)
     # Turn off the axis
     ax.axis('off')
 
-def player_bio(pitcher_id: str, ax: plt.Axes, sport_id: int, year_input: int):
+splits_title = {
+
+    'all':'',
+    'left':' vs LHH',
+    'right':' vs RHH',
+
+}
+
+type_dict =  {'R':'Regular Season',
+                   'S':'Spring',
+                   'P':'Playoffs' }
+def player_bio(pitcher_id: str, ax: plt.Axes, sport_id: int,game_type: str, year_input: int,split: str,df: pl.DataFrame):
     """
     Display the player's bio information on the given axis.
 
@@ -750,6 +788,9 @@ def player_bio(pitcher_id: str, ax: plt.Axes, sport_id: int, year_input: int):
     year_input : int
         The season year.
     """
+    start_date = df['game_date'][0]
+    end_date = df['game_date'][-1]
+
     # Construct the URL to fetch player data
     url = f"https://statsapi.mlb.com/api/v1/people?personIds={pitcher_id}&hydrate=currentTeam"
 
@@ -764,19 +805,24 @@ def player_bio(pitcher_id: str, ax: plt.Axes, sport_id: int, year_input: int):
     weight = data['people'][0]['weight']
 
     # Display the player's name, handedness, age, height, and weight on the axis
-    ax.text(0.5, 1, f'{player_name}', va='top', ha='center', fontsize=56)
-    ax.text(0.5, 0.7, f'{pitcher_hand}HP, Age: {age}, {height}/{weight}', va='top', ha='center', fontsize=30)
-    ax.text(0.5, 0.45, f'Season Pitching Summary', va='top', ha='center', fontsize=40)
+    ax.text(0.5, 1, f'{player_name}', va='top', ha='center', fontsize=36)
+    ax.text(0.5, 0.68, f'{pitcher_hand}HP, Age: {age}, {height}/{weight}', va='top', ha='center', fontsize=24)
 
+    # Convert the JSON response into a Polars DataFrame
     # Make API call to retrieve sports information
     response = requests.get(url='https://statsapi.mlb.com/api/v1/sports').json()
-    
-    # Convert the JSON response into a Polars DataFrame
+        
     df_sport_id = pl.DataFrame(response['sports'])    
     abb = df_sport_id.filter(pl.col('id') == sport_id)['abbreviation'][0]
+    # title = f'{df["game_date"][0]} vs {df["batter_team"][0]} ({type_dict[game_type[0]]}){split_title[split]}'
+    ax.text(0.5, 0.45, f'{year_input} {abb} {type_dict[game_type]}', va='top', ha='center', fontsize=24)
+
+
+
 
     # Display the season and sport abbreviation
-    ax.text(0.5, 0.20, f'{year_input} {abb} Season', va='top', ha='center', fontsize=30, fontstyle='italic')
+    ax.text(0.5, 0.20, f'{start_date} to {end_date}{splits_title[split]}', va='top', ha='center', fontsize=24, fontstyle='italic')
+
 
     # Turn off the axis
     ax.axis('off')
@@ -861,9 +907,9 @@ def plot_logo(pitcher_id: str, ax: plt.Axes, df_team: pl.DataFrame, df_players:
         img = Image.open(BytesIO(response.content))
 
         # Display the image on the axis
-        ax.set_xlim(0, 1.3)
+        ax.set_xlim(0, 1)
         ax.set_ylim(0, 1)
-        ax.imshow(img, extent=[0.3, 1.3, 0, 1], origin='upper')
+        ax.imshow(img, extent=[0, 1, 0, 1], origin='upper')
 
         # Turn off the axis
         ax.axis('off')