Update app.py

app.py

@@ -100,8 +100,12 @@ dict_pitch_desc_type.update({'All':'All'})
 dict_pitch_name = {value['name']: value['colour'] for key, value in pitch_colours.items()}
 dict_pitch_name.update({'Four-Seam Fastball':'#FF007D'})
 dict_pitch_name.update({'4-Seam':'#FF007D'})
+dict_pitch.update({'FF':'Four-Seam Fastball'})
 
 
+# Sort dict_pitch alphabetically by pitch name
+dict_pitch_alpha = dict(sorted(dict_pitch.items(), key=lambda item: item[1]))
+
 from shiny import App, reactive, ui, render
 from shiny.ui import h2, tags
 
@@ -110,6 +114,25 @@ app_ui = ui.page_fluid(
     ui.layout_sidebar(
         ui.panel_sidebar(
             # Row for selecting season and level
+             ui.row(
+                ui.markdown("## Spring Training Pitch Plots"),
+                ui.markdown("This app generates a movement plot for a pitcher's pitches in Spring Training games. You can highlight and update pitch types by selecting points on the plot."),
+                ui.column(4,ui.div(
+                    "By: ",
+                    ui.tags.a(
+                        "@TJStats",
+                        href="https://x.com/TJStats",
+                        target="_blank"
+                    )
+                ),
+                ui.tags.p("Data: MLB")),
+                ui.column(8,
+                ui.tags.p(
+                    ui.tags.a(
+                        "Support me on Patreon for more apps",
+                        href="https://www.patreon.com/TJ_Stats",
+                        target="_blank"
+                    )))),         
             ui.row(
                 ui.column(4, ui.input_select('year_input', 'Select Season', year_list, selected=2025)),
                 ui.column(4, ui.input_select('level_input', 'Select Level', level_dict)),
@@ -125,8 +148,16 @@ app_ui = ui.page_fluid(
             ui.row(
                 ui.column(6, ui.input_select('split_id', 'Select Split', split_dict, multiple=False)),
             ),
+            ui.row( ui.column(6,ui.input_select(
+                    "new_pitch_type",
+                    "Update Pitch Type",
+                dict_pitch_alpha
+                )),
+               ui.column(6,ui.input_action_button("update_pitch_type", "Update Pitch Type", class_="btn-secondary"))),
+
+            # ui.hr(),
             # Row for the action button to generate plot
-            ui.row(ui.input_action_button("generate_plot", "Generate Plot", class_="btn-primary")),
+            ui.row(ui.input_action_button("generate_plot", "Generate/Reset Plot", class_="btn-primary")),
             ui.row(ui.input_action_button("generate_table", "Generate Table", class_="btn-warning")),
             
         ),
@@ -287,53 +318,163 @@ ui.card(
     )
 )
 
-
 def server(input, output, session):
+# This code should be inserted in your server function
 
-    @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])
-        print('sportid',input.type_input())
-        # Simulate an expensive data operation
-        game_list  = scrape.get_player_games_list(sport_id = sport_id,
-                                                season = year_input, 
-                                                player_id = player_input,
-                                                start_date = start_date,
-                                                end_date = end_date,
-                                                game_type = [input.type_input()])
-
-        data_list = scrape.get_data(game_list_input = game_list[:])
-
-        try:
-            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("start_speed") >= 50)&
-                                (pl.col('batter_hand').is_in(split_dict_hand[input.split_id()]))
+    # Add this near the top of the server function
+    modified_data = reactive.value(None)
+    # Add a reactive value to store the current selection state
+    selection_state = reactive.value(None)
     
-                                )))).with_columns(
-                    pl.col('pitch_type').count().over('pitch_type').alias('pitch_count')
-                ))
-
-            df = df.with_columns(
-                prop_percent=(pl.col('is_pitch') / pl.col('is_pitch').sum()).over("pitch_type"),
-                prop=pl.col('is_pitch').sum().over("pitch_type")
+    # Create reactive values to track the state of all data-dependent inputs
+    last_pitcher_id = reactive.value(None)
+    last_date_id = reactive.value(None)
+    last_split_id = reactive.value(None)
+    last_type_input = reactive.value(None)
+    last_level_input = reactive.value(None)
+    last_year_input = reactive.value(None)
+    
+    # Modify your brush handler to update the selection state
+    @reactive.effect
+    @reactive.event(input.plot_brush)
+    def _():
+        brush_data = input.plot_brush()
+        selection_state.set(brush_data)  # Store the current brush data
+
+    # Reset modified data when any of the key inputs change
+    @reactive.effect
+    @reactive.event(input.pitcher_id, input.date_id, input.split_id, 
+                    input.type_input, input.level_input, input.year_input)
+    def _reset_on_data_change():
+        # Store the current values for comparison
+        current_pitcher = input.pitcher_id()
+        current_date = input.date_id()
+        current_split = input.split_id()
+        current_type = input.type_input()
+        current_level = input.level_input()
+        current_year = input.year_input()
+        
+        # Check if any of the inputs have changed from their last values
+        # and they aren't None or initial values
+        pitcher_changed = (last_pitcher_id() is not None and current_pitcher != last_pitcher_id())
+        date_changed = (last_date_id() is not None and current_date != last_date_id())
+        split_changed = (last_split_id() is not None and current_split != last_split_id())
+        type_changed = (last_type_input() is not None and current_type != last_type_input())
+        level_changed = (last_level_input() is not None and current_level != last_level_input())
+        year_changed = (last_year_input() is not None and current_year != last_year_input())
+        
+        # If any of the inputs have changed
+        if (pitcher_changed or date_changed or split_changed or 
+            type_changed or level_changed or year_changed):
+            # Reset modified data
+            modified_data.set(None)
+            
+            # Show notification 
+            changed_inputs = []
+            if pitcher_changed: changed_inputs.append("pitcher")
+            if date_changed: changed_inputs.append("date range")
+            if split_changed: changed_inputs.append("split")
+            if type_changed: changed_inputs.append("game type")
+            if level_changed: changed_inputs.append("league level")
+            if year_changed: changed_inputs.append("year")
+            
+            if changed_inputs:
+                change_text = ", ".join(changed_inputs)
+                ui.notification_show(f"Data filter changed ({change_text}), pitch modifications reset", type="info")
+        
+        # Update the last values
+        last_pitcher_id.set(current_pitcher)
+        last_date_id.set(current_date)
+        last_split_id.set(current_split)
+        last_type_input.set(current_type)
+        last_level_input.set(current_level)
+        last_year_input.set(current_year)
+    @reactive.effect
+    @reactive.event(input.update_pitch_type)
+    def _():
+        if input.plot_brush() is None:
+            ui.notification_show("Please select points first", type="warning")
+            return
+        
+        # Get the current data - either use the previously modified data or fetch fresh data
+        if modified_data() is not None:
+            # Use already modified data to preserve previous changes
+            df = modified_data().copy()
+        else:
+            # First time modifying, get fresh 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])
+            
+            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()]
             )
-
             
-            return df
-
+            data_list = scrape.get_data(game_list_input=game_list[:])
             
-        except TypeError:
-            print("NONE")
-            return None
+            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("start_speed") >= 50) &
+                            (pl.col('batter_hand').is_in(split_dict_hand[input.split_id()]))
+                        )
+                    )
+                )
+            )).to_pandas()
+        
+        # Get the brushed points
+        brushed = brushed_points(
+            df,
+            input.plot_brush(),
+            xvar="hb",
+            yvar="ivb",
+            all_rows=False
+        )
+        
+        if len(brushed) == 0:
+            ui.notification_show("No points selected", type="warning")
+            return
+        
+        # Update pitch types for brushed points
+        new_pitch_type = input.new_pitch_type()
+        indices = brushed.index
+        df.loc[indices, 'pitch_type'] = new_pitch_type
+        df.loc[indices, 'pitch_description'] = dict_pitch[new_pitch_type]
+        
+        # Store the modified data for future updates
+        modified_data.set(df)
+        
+        # Recalculate percentages and counts
+        pl_df = pl.from_pandas(df)
+        pl_df = pl_df.with_columns(
+            prop_percent=(pl.col('is_pitch') / pl.col('is_pitch').sum()).over("pitch_type"),
+            prop=pl.col('is_pitch').sum().over("pitch_type")
+        )
+        
+        # Convert back to pandas and update the reactive value
+        modified_data.set(pl_df.to_pandas())
         
+        # Show success notification
+        ui.notification_show(f"Updated {len(indices)} pitches to {dict_pitch[new_pitch_type]}", type="success")
+    
+    # Reset button handler - clear modified data to start fresh
+    # @reactive.effect
+    # @reactive.event(input.reset_changes)
+    # def _reset_modifications():
+    #     modified_data.set(None)
+    #     ui.notification_show("All pitch type changes have been reset", type="info")
+
+
 
     @render.ui
     @reactive.event(input.player_button, input.year_input, input.level_input, input.type_input,ignore_none=False)
@@ -347,9 +488,6 @@ def server(input, output, session):
         
         # 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)
@@ -381,25 +519,75 @@ def server(input, output, session):
             "clip": True,  # This helps constrain the brush to the plot area
             "fill": "#00000033",  # Optional: sets a semi-transparent fill
             "stroke": "#000000",    # Resets brush when new data is loaded
-
         }
             
-    
         return ui.output_plot('plot', 
                             width='800px', 
                             height='800px',
                             brush=ui.brush_opts(**brush_opts_kwargs))
 
     @render.table
-    @reactive.event(input.plot_brush, input.generate_table)  # Note: changed to match the brush ID
+    @reactive.event(input.plot_brush,input.generate_plot, input.generate_table, input.update_pitch_type)
     def in_brush():
         # if input.plot_brush() is None:  # Note: changed to match the brush ID
         #     return None
 
+        
+        # Use modified data if available
+        if modified_data() is not None:
+            df = pl.from_pandas(modified_data())
+        else:
 
-        df = 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])
+            print('sportid',input.type_input())
+            # Simulate an expensive data operation
+            game_list  = scrape.get_player_games_list(sport_id = sport_id,
+                                                    season = year_input, 
+                                                    player_id = player_input,
+                                                    start_date = start_date,
+                                                    end_date = end_date,
+                                                    game_type = [input.type_input()])
+
+            data_list = scrape.get_data(game_list_input = game_list[:])
+
+            try:
+                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("start_speed") >= 50)&
+                                    (pl.col('batter_hand').is_in(split_dict_hand[input.split_id()]))
         
-        brushed_df = pl.DataFrame(brushed_points(
+                                    )))).with_columns(
+                        pl.col('pitch_type').count().over('pitch_type').alias('pitch_count')
+                    ))
+
+                df = df.with_columns(
+                    prop_percent=(pl.col('is_pitch') / pl.col('is_pitch').sum()).over("pitch_type"),
+                    prop=pl.col('is_pitch').sum().over("pitch_type")
+                )
+
+                
+                
+        
+                
+            except TypeError:
+                print("NONE")
+                return None
+                
+        # df = df.clone()
+
+        # print('TABLE DF:',brushed_points())
+
+        if input.plot_brush() is None:
+            brushed_df = df.clone()
+            print('TABLE DF:',df)
+        
+        else:
+            brushed_df = pl.DataFrame(brushed_points(
             df.to_pandas(),
             input.plot_brush(),
             xvar="hb",
@@ -407,6 +595,8 @@ def server(input, output, session):
             all_rows=False
         ))
 
+
+
     
         brushed_df_final = (((brushed_df.group_by(['pitcher_id', 'pitch_description']).agg([
                         pl.col('is_pitch').drop_nans().count().alias('pitches'),
@@ -501,236 +691,90 @@ def server(input, output, session):
                 .applymap(lambda x: f'background-color: black' if x == 0 else '', subset=['Spin'])
                 
                                                 
-    )
+        )
+
+        print('BRUSHED:',df_brush_style)
 
         return df_brush_style
 
-        # return Tabulator(
-        #     brushed_df.to_pandas(),
-        #     table_options=TableOptions(
-        #         height=800,
-        #         resizable_column_fit=True,
-        #     )
-        # )
-        # return brushed_points(
-        #     ((brushed_df.group_by(['pitcher_id', 'pitch_description'])
-        #             .agg([
-        #                 pl.col('is_pitch').drop_nans().count().alias('pitches'),
-        #                 pl.col('start_speed').drop_nans().mean().round(1).alias('start_speed'),
-        #                 pl.col('vb').drop_nans().mean().round(1).alias('vb'),
-        #                 pl.col('ivb').drop_nans().mean().round(1).alias('ivb'),
-        #                 pl.col('hb').drop_nans().mean().round(1).alias('hb'),
-        #                 pl.col('spin_rate').drop_nans().mean().round(0).alias('spin_rate'),
-        #                 pl.col('x0').drop_nans().mean().round(1).alias('x0'),
-        #                 pl.col('z0').drop_nans().mean().round(1).alias('z0'),
-        #                 pl.col('tj_stuff_plus').drop_nans().mean().round(0).alias('tj_stuff_plus'),
-        #             ])
-        #             .with_columns(
-        #                 (pl.col('pitches') / pl.col('pitches').sum().over('pitcher_id') * 100)
-        #                 .round(1)
-        #                 .map_elements(lambda x: f"{x}%", return_dtype=pl.Utf8)  # Properly append "%"
-        #                 .alias('proportion')
-        #             )
-        #             )).sort('proportion', descending=True).
-        #             select(["pitch_description", "pitches", "proportion", "start_speed", "ivb", "hb",
-        #                                                            "spin_rate", "x0", "z0",'tj_stuff_plus'])
-        #             .rename({
-        #                 'pitch_description': 'Pitch Type',
-        #                 'pitches': 'Pitches',
-        #                 'proportion': 'Proportion',
-        #                 'start_speed': 'Velocity',
-        #                 'ivb': 'iVB',
-        #                 'hb': 'HB',
-        #                 'spin_rate': 'Spin Rate',
-        #                 'x0': 'hRel',
-        #                 'z0': 'vRel',
-        #                 'tj_stuff_plus': 'tjStuff+'
-        #             }).to_pandas(),
-        #             input.plot_brush(),  # Note: changed to match the brush ID
-        #             xvar="HB",  # Replace "x" with your actual x-axis column name
-        #             yvar="iVB",  # Replace "y" with your actual y-axis column name
-        #             all_rows=False
-        # )
-       
-        
 
-        # return brushed_points(
-        #     ((cached_data().group_by(['pitcher_id', 'pitch_description'])
-        #             .agg([
-        #                 pl.col('is_pitch').drop_nans().count().alias('pitches'),
-        #                 pl.col('start_speed').drop_nans().mean().round(1).alias('start_speed'),
-        #                 pl.col('vb').drop_nans().mean().round(1).alias('vb'),
-        #                 pl.col('ivb').drop_nans().mean().round(1).alias('ivb'),
-        #                 pl.col('hb').drop_nans().mean().round(1).alias('hb'),
-        #                 pl.col('spin_rate').drop_nans().mean().round(0).alias('spin_rate'),
-        #                 pl.col('x0').drop_nans().mean().round(1).alias('x0'),
-        #                 pl.col('z0').drop_nans().mean().round(1).alias('z0'),
-        #                 pl.col('tj_stuff_plus').drop_nans().mean().round(0).alias('tj_stuff_plus'),
-        #             ])
-        #             .with_columns(
-        #                 (pl.col('pitches') / pl.col('pitches').sum().over('pitcher_id') * 100)
-        #                 .round(1)
-        #                 .map_elements(lambda x: f"{x}%", return_dtype=pl.Utf8)  # Properly append "%"
-        #                 .alias('proportion')
-        #             )
-        #             )).sort('proportion', descending=True).
-        #             select(["pitch_description", "pitches", "proportion", "start_speed", "ivb", "hb",
-        #                                                            "spin_rate", "x0", "z0",'tj_stuff_plus'])
-        #             .rename({
-        #                 'pitch_description': 'Pitch Type',
-        #                 'pitches': 'Pitches',
-        #                 'proportion': 'Prop',
-        #                 'start_speed': 'Velocity',
-        #                 'ivb': 'iVB',
-        #                 'hb': 'HB',
-        #                 'spin_rate': 'Spin Rate',
-        #                 'x0': 'hRel',
-        #                 'z0': 'vRel',
-        #                 'tj_stuff_plus': 'tjStuff+'
-        #             }).to_pandas(),
-        #             input.plot_brush(),  # Note: changed to match the brush ID
-        #             xvar="HB",  # Replace "x" with your actual x-axis column name
-        #             yvar="iVB",  # Replace "y" with your actual y-axis column name
-        #             all_rows=False
-        # )
-    # @output
+        # @output
     @render.plot
-    @reactive.event(input.generate_plot)   
-    def plot():     
-        # Show progress/loading notification
+    @reactive.event(input.generate_plot, input.update_pitch_type)
+    def plot():
+        # Initialize progress bar+
         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])
+            game_type = [input.type_input()]
+            p.set(message="Generating plot", detail="This may take a while...")
+            
+            # Use modified data if available
+            if modified_data() is not None:
+                df = pl.from_pandas(modified_data())
+            else:
+                # Get input parameters
+                p.set(0.3, "Gathering data...")
 
-            print(year_input, sport_id, player_input, start_date, end_date)
-
-            df = cached_data()
-            if df is None:
-                    fig = plt.figure(figsize=(10,10))
-                    fig.text(x=0.1,y=0.9,s='No Statcast Data For This Pitcher',fontsize=24,ha='left')
+                
+                # Get game data
+                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=game_type
+                )
+                
+                data_list = scrape.get_data(game_list_input=game_list[:])
+                
+                # Process data
+                try:
+                    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("start_speed") >= 50) &
+                                    (pl.col('batter_hand').is_in(split_dict_hand[input.split_id()]))
+                                )
+                            )
+                        )
+                    )).with_columns(
+                        pl.col('pitch_type').count().over('pitch_type').alias('pitch_count')
+                    )
+                    
+                    df = df.with_columns(
+                        prop_percent=(pl.col('is_pitch') / pl.col('is_pitch').sum()).over("pitch_type"),
+                        prop=pl.col('is_pitch').sum().over("pitch_type")
+                    )
+                    
+                except TypeError:
+                    print("NONE")
+                    return None
+                    
+                if df is None:
+                    fig = plt.figure(figsize=(10, 10))
+                    fig.text(x=0.1, y=0.9, s='No Statcast Data For This Pitcher', fontsize=24, ha='left')
                     return fig
-            df = df.clone()
-
-
-
+                    
+                df = df.clone()
+                
+            # Create plot
             p.set(0.6, "Creating plot...")
-
-            # fig, ax = plt.subplots(figsize=(8, 8))
-
-            ploter.final_plot(
+            return ploter.final_plot(
                 df=df,
                 pitcher_id=player_input,
-                plot_picker='short_form_movement',#plot_picker,
+                plot_picker='short_form_movement',
                 sport_id=sport_id,
-                game_type = [input.type_input()])
-
-
-
-            # # Adjust the plot layout after creation
-            # plt.subplots_adjust(
-            #     top=0.95,      # Reduce top margin
-            #     bottom=0.1,    # Increase bottom margin
-            #     left=0.1,      # Increase left margin
-            #     right=0.95     # Reduce right margin
-            # )
-  
-            # #plt.rcParams["figure.figsize"] = [10,10]
-            # fig = plt.figure(figsize=(26,26))
-            # plt.rcParams.update({'figure.autolayout': True})
-            # fig.set_facecolor('white')
-            # sns.set_theme(style="whitegrid", palette=colour_palette)
-            # print('this is the one plot')
-
-            # gs = gridspec.GridSpec(6, 8,
-            #                     height_ratios=[5,20,12,36,36,7],
-            #                     width_ratios=[4,18,18,18,18,18,18,4])
-
-
-            # gs.update(hspace=0.2, wspace=0.5)
-
-            # # Define the positions of each subplot in the grid
-            # ax_headshot = fig.add_subplot(gs[1,1:3])
-            # ax_bio = fig.add_subplot(gs[1,3:5])
-            # ax_logo = fig.add_subplot(gs[1,5:7])
-
-            # ax_season_table = fig.add_subplot(gs[2,1:7])
-
-            # ax_plot_1 = fig.add_subplot(gs[3,1:3])
-            # ax_plot_2 = fig.add_subplot(gs[3,3:5])
-            # ax_plot_3 = fig.add_subplot(gs[3,5:7])
-
-            # ax_table = fig.add_subplot(gs[4,1:7])
-
-            # ax_footer = fig.add_subplot(gs[-1,1:7])
-            # ax_header = fig.add_subplot(gs[0,1:7])
-            # ax_left = fig.add_subplot(gs[:,0])
-            # ax_right = fig.add_subplot(gs[:,-1])
-
-            # # Hide axes for footer, header, left, and right
-            # ax_footer.axis('off')
-            # ax_header.axis('off')
-            # ax_left.axis('off')
-            # ax_right.axis('off')
-
-            # sns.set_theme(style="whitegrid", palette=colour_palette)
-            # fig.set_facecolor('white')
-
-            # df_teams = scrape.get_teams()
-
-            # player_headshot(player_input=player_input, ax=ax_headshot,sport_id=sport_id,season=year_input)
-            # player_bio(pitcher_id=player_input, ax=ax_bio,sport_id=sport_id,year_input=year_input)
-            # 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)
-
-            # # break_plot(df=df_plot,ax=ax2) 
-            # for x,y,z in zip([input.plot_id_1(),input.plot_id_2(),input.plot_id_3()],[ax_plot_1,ax_plot_2,ax_plot_3],[1,3,5]):
-            #     if x == 'velocity_kdes':
-            #                 velocity_kdes(df,
-            #                 ax=y,
-            #                 gs=gs,
-            #                 gs_x=[3,4],
-            #                 gs_y=[z,z+2],
-            #                 fig=fig)
-            #     if x == 'tj_stuff_roling':
-            #         tj_stuff_roling(df=df,
-            #                     window=int(input.rolling_window()),
-            #                     ax=y)
-                    
-            #     if x == 'tj_stuff_roling_game':
-            #         tj_stuff_roling_game(df=df, 
-            #                             window=int(input.rolling_window()),
-            #                             ax=y)
-
-            #     if x == 'break_plot':
-            #         break_plot(df = df,ax=y) 
-
-            #     if x == 'location_plot_lhb':
-            #         location_plot(df = df,ax=y,hand='L')
-
-            #     if x == 'location_plot_rhb':
-            #         location_plot(df = df,ax=y,hand='R')
-
-            # summary_table(df=df,
-            #             ax=ax_table)
-
-            # plot_footer(ax_footer)   
-
-            # fig.subplots_adjust(left=0.01, right=0.99, top=0.99, bottom=0.01)
+                game_type=[input.type_input()]
+            )
 
-            # fig.savefig('test.svg')
-            
             
 
 app = App(app_ui, server)