def modify_doc(doc): p1 = Plot(plot_height=400, plot_width=400, x_range=Range1d(0, 1), y_range=Range1d(0, 1), min_border=10) p2 = Plot(plot_height=400, plot_width=400, x_range=Range1d(0, 1), y_range=Range1d(0, 1), min_border=10) button = Button(css_classes=['foo']) layout = column(p1, button) def cb(event): if p2 not in layout.children: layout.children = [p1, button, p2] button.on_event('button_click', cb) def iw(attr, old, new): data['iw'] = (old, new) def ih(attr, old, new): data['ih'] = (old, new) p2.on_change('inner_width', iw) p2.on_change('inner_height', ih) doc.add_root(layout)
def main(): plots = [ figure(title='Styles Demo {i}'.format(i=i + 1), plot_width=200, plot_height=200, tools='') for i in range(9) ] [plot.line(np.arange(10), np.random.random(10)) for plot in plots] button_bokeh = Button(label="Custom Style: Bokeh Button", css_classes=['custom_button_bokeh']) button_bokeh.name = 'button_text' button_bokeh.on_event(ButtonClick, on_button_click_event_callback) curdoc().add_root(button_bokeh) curdoc().add_root(gridplot(children=[plot for plot in plots], ncols=3)) cur_doc = curdoc() # cur_doc.on_event(DocumentUpdate, on_document_update_event_callback) cur_doc.on_event(DocumentPatchedEvent, on_document_patch_event_callback) cur_doc.theme = Theme( filename= "G:\\dt-boot\\dt-data-analysis-visual\\app\\api\\server_visual\\timeseries-multi\\dark-theme.yaml" ) cur_doc.on_session_destroyed(on_session_destroyed) # cur_doc.add_periodic_callback(on_periodic_callback, 1000) cur_doc.add_next_tick_callback(on_next_tick_callback)
def test_buttonclick_event_callbacks(): button = Button() test_callback = EventCallback() button.on_event(events.ButtonClick, test_callback) assert test_callback.event_name == None button._trigger_event(events.ButtonClick(button)) assert test_callback.event_name == events.ButtonClick.event_name
def hookUpPlots(pCandle, pBuySell, pVolume, divCandle, divText, crosshairTool, pDebug): pCandle.x_range = pBuySell.x_range pVolume.x_range = pBuySell.x_range pCandle.add_tools(crosshairTool) pBuySell.add_tools(crosshairTool) pVolume.add_tools(crosshairTool) pCandle.xaxis.ticker = [8.75, 9, 9.5, 10, 10.5, 11, 11.5, 13, 13.5, 14, 14.5, 14.75] pCandle.xaxis.major_label_overrides = { 8.5:"8:30", 8.75:"8:45", 9:"9:00", 9.5:"9:30", 10:"10:00", 10.5:"10:30", 11:"11:00", 11.5:"11:30", 13:"13:00", 13.5:"13:30", 14:"14:00", 14.5:"14:30", 14.75:"14:45"} pBuySell.xaxis.ticker = pCandle.xaxis.ticker pVolume.xaxis.ticker = pCandle.xaxis.ticker pVolume.xaxis.major_label_overrides = pCandle.xaxis.major_label_overrides def btnStart_clicked(event): btnStart._document.get_model_by_name("btnStart").label = "Started!" # activation_function() def activation_function(): btnStart._document.add_periodic_callback(lambda: updateDoc(btnStart._document), 1000) btnStart._document.get_model_by_name("btnStart").label = "Started!" btnStart.disabled = True pLabel = Paragraph(text="Debug information (please ignore): ", width=pDebug.width, height=10, name="pLabel") btnStart = Button(label="Start automatic update", button_type="success", name="btnStart") btnStart.on_event(ButtonClick, btnStart_clicked) return row(column(pCandle, pBuySell, pVolume), column(divCandle, btnStart, divText, pLabel, pDebug)), \ activation_function
def test_event_handles_new_callbacks_in_event_callback(self) -> None: from bokeh.models import Button d = document.Document() button1 = Button(label="1") button2 = Button(label="2") def clicked_1(): button2.on_event('button_click', clicked_2) d.add_root(button2) def clicked_2(): pass button1.on_event('button_click', clicked_1) d.add_root(button1) decoder = Deserializer(references=[button1]) event = decoder.decode( dict( type="event", name="button_click", values=dict(model=dict(id=button1.id)), )) try: d.callbacks.trigger_event(event) except RuntimeError: pytest.fail( "trigger_event probably did not copy models before modifying")
def modify(doc): button = Button(label="Foo", button_type="success") def callback(event): print('Python:Click') button.on_event(ButtonClick, callback) doc.add_root(column(o.plot_BS_Pressure2(), button))
def modify_doc(doc): source = ColumnDataSource(dict(x=[1, 2], y=[1, 1])) plot = Plot(plot_height=400, plot_width=400, x_range=Range1d(0, 1), y_range=Range1d(0, 1), min_border=0) plot.add_glyph(source, Circle(x='x', y='y', size=20)) plot.add_tools(CustomAction(callback=CustomJS(args=dict(s=source), code=RECORD("data", "s.data")))) button = Button(css_classes=['foo']) def cb(event): source.data=dict(x=[10, 20], y=[10, 10]) button.on_event('button_click', cb) doc.add_root(column(button, plot))
def test_event_handles_new_callbacks_in_event_callback(self) -> None: from bokeh.models import Button d = document.Document() button1 = Button(label="1") button2 = Button(label="2") def clicked_1(): button2.on_event('button_click', clicked_2) d.add_root(button2) def clicked_2(): pass button1.on_event('button_click', clicked_1) d.add_root(button1) event_json = {"event_name": "button_click", "event_values": {"model": {"id": button1.id}}} try: d.callbacks.trigger_json_event(event_json) except RuntimeError: pytest.fail("trigger_event probably did not copy models before modifying")
def initialize(): text_output = Paragraph(text='Status', width=300, height=100) DATA_STORE.update({'text_output': text_output}) retrieve_data(initial=True) df = DATA_STORE['data'] symbols = sorted(list(set(df.index.get_level_values(level=0)))) if DATA_STORE['valid_symbols'] is None: DATA_STORE.update({'valid_symbols': symbols}) set_data_symbol() menu = [*zip(symbols, symbols)] dropdown = Dropdown(label='Select Symbol', button_type='primary', menu=menu) dropdown.on_change('value', dropdown_callback) bucket_input = TextInput(value='mlsl-mle-ws', title='S3 Bucket:') key_input = TextInput(value='training-data/crypto_test_preds.csv', title='S3 Key:') profile_input = TextInput(value='kyle_general', title='Boto Profile:') text_button = Button(label='Pull Data') text_button.on_event(ButtonClick, text_button_callback) default_button = Button(label='Reset Defaults') default_button.on_event(ButtonClick, default_button_callback) DATA_STORE.update({ 'dropdown': dropdown, 's3_bucket_input': bucket_input, 's3_key_input': key_input, 'text_button': text_button, 'boto_profile_input': profile_input, 'default_button': default_button })
p = figure(toolbar_location=None, background_fill_color="#fafafa") p.circle(x=1, y=list(range(0, 11))) p.line('x', 'y', color="orange", source=source) slider = Slider(start=0, end=10, step=0.1, value=1) def scb(attr, old, new): source.data['y'] = new * y slider.on_change('value', scb) combine = Button(label="hold combine") combine.on_event(ButtonClick, lambda event: doc.hold("combine")) collect = Button(label="hold collect") collect.on_event(ButtonClick, lambda event: doc.hold("collect")) unhold = Button(label="unhold") unhold.on_event(ButtonClick, lambda event: doc.unhold()) div = Div(text=""" <p>Bokeh Documents can be configured to "hold" property change events until a corresponding "unhold" is issued. There are two modes. In "collect" mode, all held events are replayed in order when "unhold" is called. In "combine" mode, Bokeh will coalesce events so that at most one event per property is issued.</p> <p>Click "combine" or "collect" below, and scrub the slider. Then click "unhold" to see the result.</p>
# Pan events p.js_on_event(events.Pan, display_event(div, attributes=pan_attributes)) p.js_on_event(events.PanStart, display_event(div, attributes=point_attributes)) p.js_on_event(events.PanEnd, display_event(div, attributes=point_attributes)) # Pinch events p.js_on_event(events.Pinch, display_event(div, attributes=pinch_attributes)) p.js_on_event(events.PinchStart, display_event(div, attributes=point_attributes)) p.js_on_event(events.PinchEnd, display_event(div, attributes=point_attributes)) ## Register Python event callbacks # Button event button.on_event(events.ButtonClick, print_event()) # LOD events p.on_event(events.LODStart, print_event()) p.on_event(events.LODEnd, print_event()) # Point events p.on_event(events.Tap, print_event(attributes=point_attributes)) p.on_event(events.DoubleTap, print_event(attributes=point_attributes)) p.on_event(events.Press, print_event(attributes=point_attributes)) # Mouse wheel event p.on_event(events.MouseWheel, print_event(attributes=wheel_attributes)) # Mouse move, enter and leave
title='beta (prob of E to quarantine at arrival)') spinner11 = TextInput(value='0.8', title='tau (prob of I to quarantine at arrival)') spinner12 = Slider(start=0, end=500, value=20, step=1, title='Bats?') # Matrix inputs: (Not used yet - just for show) g1 = TextInput(value='[0, 13056, 5930, 563, 355]', title='Matrix') g2 = TextInput(value='[6849, 0, 99640, 197190, 49887]') g3 = TextInput(value='[20,29300, 0, 261774, 66226]') g4 = TextInput(value='[214, 86535, 419844, 0, 237225]') g5 = TextInput(value='[153, 21950, 106494, 237846, 0]') matrix = column(g1, g2, g3, g4, g5) # Buttons to control updates/resets button_solve = Button(label="Solve", button_type="success") button_solve.on_event(ButtonClick, update) #('value', lambda attr, old, new: update()) button_reset = Button(label="Reset", button_type="warning") button_reset.on_event(ButtonClick, clear) # Organize layout figs = gridplot([fig_init, fig_init2, fig_init3, fig_init4, fig_init5], ncols=3, plot_width=400, plot_height=300) model_controls = column(spinner1, spinner2, spinner3, button_solve, button_reset) quarantine_controls = column(spinner4, spinner5, spinner6, spinner7, spinner8) quarantine_controls2 = column(spinner9, spinner10, spinner11, spinner12) controls = row(model_controls, quarantine_controls, quarantine_controls2, matrix)
def get_download_widget(datasets, series, session, key_mapper, savepath, export_folder=None, icons=None): """Return a download button.""" def callback_download(event): def serie_generator(selected_keylist): for key in selected_keylist: if key in key_mapper: yield key_mapper.get(key) def append_qc_comment(meta): time_stamp = get_time_as_format(now=True, fmt='%Y%m%d%H%M') meta[ len(meta) + 1] = '//COMNT_QC; MANUAL QC PERFORMED BY {}; TIMESTAMP {}'.format( session.settings.user, time_stamp) if not len(series.selected.indices): message_box("No files where downloaded. Did you select any?", icon_path=icons.get('question')) print('No selected series to download') print('len(series.selected.indices)', series.selected.indices) return if export_folder: path = export_folder else: path = get_folder_path_from_user() if not path: print('No download directory selected! ' 'Using the system standard download ' 'folder instead (Hämtade filer)') generator = serie_generator( [series.data['KEY'][idx] for idx in series.selected.indices]) datasets_to_update = {} for ds_name in generator: append_qc_comment(datasets[ds_name]['metadata']) datasets_to_update[ds_name] = datasets[ds_name] if datasets_to_update: selected_path = path or savepath or 'C:/QC_CTD' session.save_data( [datasets_to_update], save_path=selected_path, collection_folder=False if path else True, writer='ctd_standard_template', ) message_box( f"Download completed!\n" f"The files are stored under:\n{selected_path}", icon_path=icons.get('success')) else: message_box( "No files where downloaded. " "A guess: Not able to map between " "loaded files and file names.", icon_path=icons.get('question')) print('No download!') button = Button(label="Select directory and download data", button_type="success", width=40) button.on_event(ButtonClick, callback_download) return button
page_change() def do_prev_page(event): pdff.prev_page() page_change() def do_build(even): pdfbld.build() pdff.switch_preview_source() pdff.page_to_gif() im_source.data = {'url': [url_formatter(pdff.current_gif)]} button_next_page = Button(label="Next page") button_next_page.on_event(ButtonClick, do_next_page) button_prev_page = Button(label="Previous page") button_prev_page.on_event(ButtonClick, do_prev_page) button_build = Button(label="Build") button_build.on_event(ButtonClick, do_build) l = layout([[p], [button_next_page], [button_prev_page], [button_build]], sizing_mode='fixed') curdoc().add_root(l) curdoc().title = "Sign PDF" # %%
## Bokeh server for button click from bokeh.io import curdoc from bokeh.layouts import row from bokeh.models import Button, ColumnDataSource from bokeh.plotting import figure x=[3,4,6,12,10,1] y=[7,1,3,4,1,6] source = ColumnDataSource(data=dict(x=x, y=y)) plot_figure = figure(height=450, width=600, tools="save,reset", x_range=[0,14], y_range=[0,12], toolbar_location="below") plot_figure.scatter('x', 'y', source=source, size=10) button = Button(label="Click to set plot title", button_type="success") def button_click(): plot_figure.title.text = 'Button Clicked' button.on_event('button_click', button_click) layout=row(button,plot_figure) curdoc().add_root(layout) curdoc().title = "Button Bokeh Server"
def player_displacement_value_tab(events_df, metrica_attack, metrica_defence, bokeh_attack, bokeh_defence, shirt_mapping, match_list): import metrica_to_bokeh as mtb import Metrica_PitchControl as mpc import pitch_value_model as pvm from bokeh.models import ColumnDataSource, Select, TextInput, Panel, Div, Button, DataTable, TableColumn, Paragraph from bokeh.events import ButtonClick from bokeh.layouts import row, column, WidgetBox import numpy as np from scipy import interpolate def make_dataset(play, event_frame, metrica_attack, metrica_defence, bokeh_attack, bokeh_defence, field_dimen=( 106., 68., ), new_grid_size=500): params = mpc.default_model_params(3) event = events_df.loc[[(play, int(event_frame))]] tracking_frame = event['Start Frame'][0] att_frame = bokeh_attack.loc[(play, tracking_frame)] att_player_frame = att_frame[att_frame['player'] != "ball"] att_player_frame['Shirt Number'] = att_player_frame['player'].map( int).map(shirt_mapping[play]).fillna("") def_frame = bokeh_defence.loc[(play, tracking_frame)] def_player_frame = def_frame[def_frame['player'] != "ball"] def_player_frame['Shirt Number'] = def_player_frame['player'].map( int).map(shirt_mapping[play]).fillna("") ball_frame = att_frame[att_frame['player'] == "ball"] PPCF, xgrid, ygrid = pvm.lastrow_generate_pitch_control_for_event( play, event_frame, events_df, metrica_attack, metrica_defence, params, field_dimen=( 106., 68., ), n_grid_cells_x=50) print('calculating..') PT = pvm.generate_relevance_at_event(play, event_frame, events_df, PPCF, params) print('calculating..') PS = pvm.generate_scoring_opportunity(field_dimen=( 106., 68., ), n_grid_cells_x=50) print('calculating..') PPV = pvm.generate_pitch_value(PPCF, PT, PS, field_dimen=( 106., 68., ), n_grid_cells_x=50) print('calculating..') RPPV = pvm.generate_relative_pitch_value(play, event_frame, events_df, metrica_attack, PPV, xgrid, ygrid) xgrid_new = np.linspace(-field_dimen[0] / 2., field_dimen[0] / 2., new_grid_size) ygrid_new = np.linspace(-field_dimen[1] / 2., field_dimen[1] / 2., new_grid_size) PPCF_int = interpolate.interp2d(xgrid, ygrid, PPCF, kind='cubic') PPCF_new = PPCF_int(xgrid_new, ygrid_new) PPCF_dict = dict(image=[PPCF_new], x=[xgrid.min()], y=[ygrid.min()], dw=[field_dimen[0]], dh=[field_dimen[1]]) PT_int = interpolate.interp2d(xgrid, ygrid, PT, kind='cubic') PT_new = PT_int(xgrid_new, ygrid_new) PT_dict = dict(image=[PT_new], x=[xgrid.min()], y=[ygrid.min()], dw=[field_dimen[0]], dh=[field_dimen[1]]) PS_int = interpolate.interp2d(xgrid, ygrid, PS, kind='cubic') PS_new = PS_int(xgrid_new, ygrid_new) PS_dict = dict(image=[PS_new], x=[xgrid.min()], y=[ygrid.min()], dw=[field_dimen[0]], dh=[field_dimen[1]]) PPV_int = interpolate.interp2d(xgrid, ygrid, PPV, kind='cubic') PPV_new = PPV_int(xgrid_new, ygrid_new) PPV_dict = dict(image=[PPV_new], x=[xgrid.min()], y=[ygrid.min()], dw=[field_dimen[0]], dh=[field_dimen[1]]) RPPV_int = interpolate.interp2d(xgrid, ygrid, RPPV, kind='cubic') RPPV_new = RPPV_int(xgrid_new, ygrid_new) RPPV_dict = dict(image=[RPPV_new], x=[xgrid.min()], y=[ygrid.min()], dw=[field_dimen[0]], dh=[field_dimen[1]]) event_src = ColumnDataSource(event) att_src = ColumnDataSource(att_player_frame) def_src = ColumnDataSource(def_player_frame) ball_src = ColumnDataSource(ball_frame) PPCF_src = ColumnDataSource(PPCF_dict) PT_src = ColumnDataSource(PT_dict) PS_src = ColumnDataSource(PS_dict) PPV_src = ColumnDataSource(PPV_dict) RPPV_src = ColumnDataSource(RPPV_dict) return event_src, att_src, def_src, ball_src, PPCF_src, PT_src, PS_src, PPV_src, RPPV_src, xgrid, ygrid def make_plot(event_src, att_src, def_src, ball_src, surface_src, bokeh_attack, bokeh_defence, xgrid, ygrid, field_dimen=( 106., 68., ), new_grid_size=500, point_click=False): surface = mtb.plot_bokeh_surface_at_event(event_src, att_src, def_src, ball_src, surface_src, bokeh_attack, bokeh_defence, xgrid, ygrid, point_click=True) return surface def update(attr, old, new): match_selection = match_select.value event_selection = event_select.value new_og_event_src, new_og_att_src, new_og_def_src, new_og_ball_src, new_og_PPCF_src, new_og_PT_src, new_og_PS_src, new_og_PPV_src, new_og_RPPV_src, xgrid, ygrid = make_dataset( match_selection, event_selection, metrica_attack, metrica_defence, bokeh_attack, bokeh_defence) print('calculating..') og_att_src.data.update(new_og_att_src.data) og_def_src.data.update(new_og_def_src.data) og_ball_src.data.update(new_og_ball_src.data) og_PPCF_src.data.update(new_og_PPCF_src.data) og_PT_src.data.update(new_og_PT_src.data) og_PT_src.data.update(new_og_PS_src.data) og_PPV_src.data.update(new_og_PPV_src.data) og_RPPV_src.data.update(new_og_RPPV_src.data) new_event_src, new_att_src, new_def_src, new_ball_src, new_PPCF_src, new_PT_src, new_PS_src, new_PPV_src, new_RPPV_src, xgrid, ygrid = make_dataset( match_selection, event_selection, metrica_attack, metrica_defence, bokeh_attack, bokeh_defence) print('calculating..') event_src.data.update(new_event_src.data) att_src.data.update(new_att_src.data) def_src.data.update(new_def_src.data) ball_src.data.update(new_ball_src.data) PPCF_src.data.update(new_PPCF_src.data) PT_src.data.update(new_PT_src.data) PT_src.data.update(new_PS_src.data) PPV_src.data.update(new_PPV_src.data) RPPV_src.data.update(new_RPPV_src.data) match_select = Select(title="Select Match:", value=match_list[0], options=match_list) match_select.on_change('value', update) event_select = TextInput(title="Event:", value="0") event_select.on_change('value', update) player_select = TextInput(title="Index of Player Moved:", value="") team_select = Select(title="Team of Player Moved:", value="attack", options=["attack", "defence"]) def recalculate(event): match_selection = match_select.value event_selection = event_select.value player_selection = int(player_select.value) team_selection = team_select.value if team_selection == 'attack': player = att_src.data['player'][player_selection] shirt = att_src.data['Shirt Number'][player_selection] # attack selected_att_x = att_src.data['x'][player_selection] selected_att_y = att_src.data['y'][player_selection] og_selected_att_x = og_att_src.data['x'][player_selection] og_selected_att_y = og_att_src.data['y'][player_selection] x_displacement = selected_att_x - og_selected_att_x y_displacement = selected_att_y - og_selected_att_y metrica_attack_new = mtb.player_displacement( match_selection, event_selection, events_df, metrica_attack, metrica_defence, 'attack', player, x_displacement, y_displacement) bokeh_attack_new = mtb.tracking_to_bokeh_format(metrica_attack_new) new_event_src, new_att_src, new_def_src, new_ball_src, new_PPCF_src, new_PT_src, new_PS_src, new_PPV_src, new_RPPV_src, xgrid, ygrid = make_dataset( match_selection, event_selection, metrica_attack_new, metrica_defence, bokeh_attack_new, bokeh_defence) print('calculating..') event_src.data.update(new_event_src.data) att_src.data.update(new_att_src.data) def_src.data.update(new_def_src.data) ball_src.data.update(new_ball_src.data) PPCF_src.data.update(new_PPCF_src.data) PT_src.data.update(new_PT_src.data) PT_src.data.update(new_PS_src.data) PPV_src.data.update(new_PPV_src.data) RPPV_src.data.update(new_RPPV_src.data) pitch_value = make_plot(event_src, att_src, def_src, ball_src, PPV_src, bokeh_attack, bokeh_defence, xgrid, ygrid, field_dimen=( 106., 68., ), new_grid_size=500) relative_pitch_value = make_plot(event_src, att_src, def_src, ball_src, RPPV_src, bokeh_attack, bokeh_defence, xgrid, ygrid, field_dimen=( 106., 68., ), new_grid_size=500) elif team_selection == 'defence': player = def_src.data['player'][player_selection] shirt = def_src.data['Shirt Number'][player_selection] # defence selected_def_x = def_src.data['x'][player_selection] selected_def_y = def_src.data['y'][player_selection] og_selected_def_x = og_def_src.data['x'][player_selection] og_selected_def_y = og_def_src.data['y'][player_selection] x_displacement = selected_def_x - og_selected_def_x y_displacement = selected_def_y - og_selected_def_y metrica_defence_new = mtb.player_displacement( match_selection, event_selection, events_df, metrica_attack, metrica_defence, 'defence', player, x_displacement, y_displacement) bokeh_defence_new = mtb.tracking_to_bokeh_format( metrica_defence_new) new_event_src, new_att_src, new_def_src, new_ball_src, new_PPCF_src, new_PT_src, new_PS_src, new_PPV_src, new_RPPV_src, xgrid, ygrid = make_dataset( match_selection, event_selection, metrica_attack, metrica_defence_new, bokeh_attack, bokeh_defence_new) print('calculating..') event_src.data.update(new_event_src.data) att_src.data.update(new_att_src.data) def_src.data.update(new_def_src.data) ball_src.data.update(new_ball_src.data) PPCF_src.data.update(new_PPCF_src.data) PT_src.data.update(new_PT_src.data) PT_src.data.update(new_PS_src.data) PPV_src.data.update(new_PPV_src.data) RPPV_src.data.update(new_RPPV_src.data) pitch_value = make_plot(event_src, att_src, def_src, ball_src, PPV_src, bokeh_attack, bokeh_defence, xgrid, ygrid, field_dimen=( 106., 68., ), new_grid_size=500) relative_pitch_value = make_plot(event_src, att_src, def_src, ball_src, RPPV_src, bokeh_attack, bokeh_defence, xgrid, ygrid, field_dimen=( 106., 68., ), new_grid_size=500) recalculate_button = Button(label="Re-Calculate Pitch Value") recalculate_button.on_event(ButtonClick, recalculate) # Initial match to plot print('create initial tab2') play = 'Bayern 0 - [1] Liverpool' event_frame = 0 og_event_src, og_att_src, og_def_src, og_ball_src, og_PPCF_src, og_PT_src, og_PS_src, og_PPV_src, og_RPPV_src, xgrid, ygrid = make_dataset( play, event_frame, metrica_attack, metrica_defence, bokeh_attack, bokeh_defence) print('calculating..') event_src, att_src, def_src, ball_src, PPCF_src, PT_src, PS_src, PPV_src, RPPV_src, xgrid, ygrid = make_dataset( play, event_frame, metrica_attack, metrica_defence, bokeh_attack, bokeh_defence) print('calculating..') pitch_value = make_plot(event_src, att_src, def_src, ball_src, PPV_src, bokeh_attack, bokeh_defence, xgrid, ygrid, field_dimen=( 106., 68., ), new_grid_size=500) pitch_value.title.text = "Pitch Value" pitch_value.title.text_font_size = "20px" print('calculating..') relative_pitch_value = make_plot(event_src, att_src, def_src, ball_src, RPPV_src, bokeh_attack, bokeh_defence, xgrid, ygrid, field_dimen=( 106., 68., ), new_grid_size=500) relative_pitch_value.title.text = "Relative Pitch Value" relative_pitch_value.title.text_font_size = "20px" # Create data tables for viewing movements columns = [ TableColumn(field="Shirt Number", title="Shirt Number"), TableColumn(field="player", title="player"), TableColumn(field="x", title="x"), TableColumn(field="y", title="y"), ] att_table = DataTable(source=att_src, columns=columns, width=400, height=280, editable=True) att_title = Div(text="Red Team") def_table = DataTable(source=def_src, columns=columns, width=400, height=280, editable=True) def_title = Div(text="Blue Team") # Paragraph for instructions and disclaimers disclaimer = Paragraph( text= "*** Disclaimer - You can click the PointDrawTool in Pitch Value for each team to move a single player at a time. If you wish to re-calculate the Pitch Value based on the new location, you must add in a new player (click anywhere on the pitch with the PointDrawTool) and then remove them again (click on them to highlight only them, then press backspace). This is necessary to do for each team everytime you want to re-calculate Pitch Values. Any advice on correcting this would be appreciated! ***" ) instructions = Paragraph( text= "Select a match from the dropdown list below. Then enter an event number. If a player is moved, enter their Index to the respective table and select their team (Red = attack, Blue = defence). Pitch Value is the same as in 'Events - Pitch Value'. Relative Pitch Value highlights areas that will increase Pitch Value compared to the starting position. Again can turn off some HoverTools if necessary." ) #notes = column(disclaimer, instructions) # Layout setup control = WidgetBox( column(match_select, event_select, player_select, team_select, recalculate_button)) plots = column(pitch_value, relative_pitch_value) tables = column(column(att_title, att_table), column(def_title, def_table)) layout = column(disclaimer, instructions, row(plots, column(control, tables))) tab3 = Panel(child=layout, title='Player Displacement - Pitch Value') return tab3
x = np.linspace(0, 2, 1000) y = 1 - (x-1)**2 source = ColumnDataSource(data=dict(x=x, y=y)) p = figure(title="initial title") p.circle(x=1, y=list(range(0, 11))) p.line('x', 'y', color="orange", source=source) slider = Slider(start=0, end=10, step=0.1, value=1) def scb(attr, old, new): source.data['y'] = new * y slider.on_change('value', scb) combine = Button(label="hold combine") combine.on_event(ButtonClick, lambda event: doc.hold("combine")) collect = Button(label="hold collect") collect.on_event(ButtonClick, lambda event: doc.hold("collect")) unhold = Button(label="unhold") unhold.on_event(ButtonClick, lambda event: doc.unhold()) doc.add_root(column(p, slider, combine, collect, unhold)) @repeat(np.linspace(0, 10, 100)) def update(v): slider.value = v curdoc().add_periodic_callback(update, 200)
select = Select(title="Pick a Constituent:", value="foo", options=list(smilies_dict_select.keys())) select.on_change('value', change_text) flavor_select = Select(title="Pick a Flavor:", value="foo", options=list(form_dict_select.keys())) flavor_select.on_change('value', change_form) oil_add = Select(title="Add Oil:", value="foo", options=list(oil_dict_select.keys())) oil_add.on_change('value', add_oil) button.on_event(ButtonClick, update_title) button2.on_event(ButtonClick, run_rules) # Set up layouts and add to document col1 = column(text, conc, select, oil_add, flavor_select, button, button2) col2 = column(p) col3 = column() layout = layout([[col1, col2, col3]]) slider = None mol_list = None data = None para = None names = None sim_tab = None curdoc().add_root(layout) curdoc().title = "Conc"
class Widgets: def __init__(self, renderer): self.file_input = Dropdown(label="Select dataset", menu=[]) for dataset_name in SQLDBInformer(DbConn({})).get_all_schemas(): if dataset_name in set(["information_schema", "performance_schema", "sys", "defaultDB", "mysql"]): continue if dataset_name[:3] == "pg_": continue self.file_input.menu.append(dataset_name) self.run_id_dropdown = Dropdown(label="select run id here", menu=[]) self.ground_truth_id_dropdown = Dropdown(label="select ground truth id here", menu=[]) self.score_slider = RangeSlider(start=0, end=1, value=(0, 1), step=.1, callback_policy='mouseup', title="score range") self.max_elements_slider = Slider(start=1000, end=100000, value=10000, step=1000, callback_policy='mouseup', title="max render") self.range_link_radio = RadioGroup(labels=["Link read plot to x-range", "Link read plot to y-range"], active=0, orientation="horizontal") self.full_render_button = Button(label="render without limit") self.render_mems_button = Button(label="render MEMs") self.delete_button = Button(label="Delete Dataset") self.force_read_id = TextInput(value="", title="Render reads with ids (comma seperated list):") self.file_input.on_change("value", lambda x,y,z: self.file_input_change(renderer)) self.run_id_dropdown.on_change("value", lambda x,y,z: self.run_id_change(renderer)) self.ground_truth_id_dropdown.on_change("value", lambda x,y,z: self.ground_id_change(renderer)) self.score_slider.on_change("value_throttled", lambda x,y,z: self.slider_change(renderer)) self.max_elements_slider.on_change("value_throttled", lambda x,y,z: self.slider_change(renderer)) self.full_render_button.on_event(ButtonClick, lambda x: self.full_render(renderer)) self.render_mems_button.on_event(ButtonClick, lambda x: self.render_mems_button_event(renderer)) self.delete_button.on_event(ButtonClick, lambda x: self.delete_button_event(renderer)) self.force_read_id.on_change("value", lambda x,y,z: self.forced_read_ids_change(renderer)) self.spinner_div = Div(text=html_file("spinner"), sizing_mode="scale_both", visible=False) self.condition = threading.Condition() self.subset_buttons = CheckboxButtonGroup(labels=["Render false-positives", "Render false-negatives", "Render true-positives", "Compute Stats"], active=[0, 1, 2]) self.subset_buttons.on_click(lambda x: self.forced_read_ids_change(renderer)) self.blur_slider = Slider(start=0, end=500, value=100, step=1, callback_policy='mouseup', title="Blur") self.blur_slider.on_change("value_throttled", lambda x,y,z: self.slider_change(renderer)) def show_spinner(self, renderer): self.spinner_div.visible = True def hide_spinner(self, renderer): self.spinner_div.visible = False def file_input_change(self, renderer): with self.condition: self.file_input.label = "Selected dataset: " + self.file_input.value renderer.setup() def run_id_change(self, renderer): with self.condition: renderer.read_plot.recalc_stat = True print("new run_id:", self.run_id_dropdown.value) renderer.cached_global_overview = None run_table = SvCallerRunTable(renderer.db_conn) self.run_id_dropdown.label = "Selected run: " + run_table.getName(int(self.run_id_dropdown.value)) + \ " - " + self.run_id_dropdown.value call_table = SvCallTable(renderer.db_conn) self.score_slider.end = 0 if call_table.num_calls(int(self.run_id_dropdown.value), 0) > 0: self.score_slider.end = call_table.max_score(int(self.run_id_dropdown.value)) + 1 self.score_slider.value = (0, self.score_slider.end) renderer.render(ignorable=False) def ground_id_change(self, renderer): with self.condition: renderer.read_plot.recalc_stat = True run_table = SvCallerRunTable(renderer.db_conn) self.ground_truth_id_dropdown.label = "Selected ground truth: " + \ run_table.getName(int(self.ground_truth_id_dropdown.value)) + \ " - " + self.ground_truth_id_dropdown.value renderer.render(ignorable=False) def slider_change(self, renderer): renderer.read_plot.recalc_stat = True renderer.render(ignorable=False) def forced_read_ids_change(self, renderer): renderer.render(ignorable=False) def full_render(self, renderer): renderer.render(render_all=True, ignorable=False) def get_blur(self): return self.blur_slider.value def get_render_f_p(self): return 0 in self.subset_buttons.active def get_render_f_n(self): return 1 in self.subset_buttons.active def get_render_t_p(self): return 2 in self.subset_buttons.active def compute_stats(self): return 3 in self.subset_buttons.active def get_forced_read_ids(self, renderer): if len(self.force_read_id.value) == 0: return [] read_table = ReadTable(renderer.db_conn) ret = [] for id_n_name in self.force_read_id.value.split(";"): split = id_n_name.split(":") if not len(split) == 2: continue seq_id, name = split idx = read_table.get_read_id(int(seq_id), name) if idx == -1: print(name, "does not exist in DB") continue ret.append(idx) return ret def render_mems_button_event(self, renderer): if not renderer.selected_read_id is None: read = ReadTable(renderer.db_conn).get_read(renderer.selected_read_id) seed_plot_y_s = int(max(renderer.read_plot.plot.y_range.start, 0)) seed_plot_y_e = int(min(renderer.read_plot.plot.y_range.end, len(read))) seed_plot_x_s = int(max(renderer.read_plot.plot.x_range.start, 0)) seed_plot_x_e = int(min(renderer.read_plot.plot.x_range.end, renderer.pack.unpacked_size_single_strand)) filtered_mems = compute_seeds_area(renderer.params, seed_plot_x_s, seed_plot_y_s, seed_plot_x_e-seed_plot_x_s, seed_plot_y_e-seed_plot_y_s, read, renderer.pack) seed_data_new = dict((key, []) for key in renderer.read_plot.seeds.data.keys()) if len(filtered_mems) > 0: max_seed_size = max( seed.size for seed in filtered_mems ) for idx in range(len(filtered_mems)): add_seed(filtered_mems[idx], seed_data_new, max_seed_size, [], [], 0, False, -1, renderer.selected_read_id, idx, read.name) renderer.read_plot.seeds.data = seed_data_new def delete_button_event(self, renderer): print("unimplemented at the moment...") #renderer.sv_db.delete_run(renderer.get_run_id()) renderer.setup()
def bkapp(self, doc): basePath = self.basePath npyPath = self.npyPath covMapDict = self.covMapDict self.logger.debug('basePath: ' + str(basePath)) self.logger.debug('npyPath: ' + str(npyPath)) self.logger.debug('covMapDict: ' + str(covMapDict)) # Retrieving Data #----------------------------------------------------------------- # Loading in data curPath = os.getcwd() # Loading distance difference matrices self.logger.info('Reading npy matrices from: ' + str(npyPath)) npyNameList = [npyFile for npyFile in os.listdir(npyPath) \ if (npyFile[-3:] == 'npy') \ and ('Minus' in npyFile) \ and ('Scaled' not in npyFile)] self.logger.debug('npyNameList: ' + str(npyNameList)) npyList = [None] * len(npyNameList) for i, npyName in enumerate(npyNameList): npyList[i] = np.load(os.path.join(npyPath, npyName)) self.logger.debug('npyList: ' + str(npyList)) # Loading and defining dictionaries to map to and fro residue pairs to # the corresponding submatrices invCovMapDict = {str(value): key for key, value in covMapDict.items()} # Loading Covariance Matrix and helper class to split submatrices self.logger.info('Loading CovarianceMatrix.npy') covarianceMatrix = np.load(os.path.join(basePath, \ 'CovarianceMatrix.npy')) self.covSize = covarianceMatrix.shape[0] self.logger.info('Loaded CovarianceMatrix.npy') cSubmatrix = CovSubmatrix() #----------------------------------------------------------------- # Interactive Plot Tools TOOLS = 'hover,save,pan,box_zoom,reset,wheel_zoom' # Defining color values vmin = -5 vmax = 5 # New Color Map Bokeh blueRedColors = [ '#FF0000', '#FF1111', '#FF2222', '#FF3333', '#FF4444', '#FF5555', '#FF6666', '#FF7777', '#FF8888', '#FF9999', '#FFAAAA', '#FFBBBB', '#FFCCCC', '#FFDDDD', '#FFEEEE', '#FFFFFF', '#EEEEFF', '#DDDDFF', '#CCCCFF', '#BBBBFF', '#AAAAFF', '#9999FF', '#8888FF', '#7777FF', '#6666FF', '#5555FF', '#4444FF', '#3333FF', '#2222FF', '#1111FF', '#0000FF' ] # Creating list axesXMax = npyList[0].shape[0] if int(self.scale) != int(npyList[0].shape[0]): axesXMax = self.scale axesYMax = npyList[0].shape[1] if int(self.scale) != int(npyList[0].shape[1]): axesYMax = self.scale xyPairList = [None] * axesXMax * axesYMax for i in range(0, axesXMax): for j in range(0, axesYMax): xyPairList[i + j * axesXMax] = (i + 1, j + 1) self.logger.debug('xyPairList: ' + str(xyPairList)) self.logger.debug('type: xyPairList: ' + str(type(xyPairList))) # Reshaping source values in order to shift indices from starting # with 0 to starting with 1 xVals = np.transpose(xyPairList)[0] yVals = np.transpose(xyPairList)[1] covVals = npyList[0].flatten() self.logger.debug('npyList: ' + str(npyList)) self.logger.debug('covVals: ' + str(covVals)) # Checks to see if the specified scale matches axesLength = int(np.sqrt(len(covVals))) self.indexDict = None self.scaledRangeDict = None if axesLength != int(self.scale): axesLength = self.scale newMatrix, self.indexDict = self.rescaleMatrix(covVals, self.scale) covVals = newMatrix.flatten() # Creating a dictionary mapping the new indices to # strings describing the ranges of the original indices if self.indexDict is not None: self.scaledRangeDict = self.serializeIndexDict(self.indexDict) # Saving the scaled index mapping to file indexDictFilepath = os.path.join(basePath, 'scaledIndexMap.npy') np.save(indexDictFilepath, self.indexDict, allow_pickle=True) self.logger.info('Saving the scaled index mapping to: ' \ + str(indexDictFilepath)) self.logger.debug('scaledRangeDict: ' + str(self.scaledRangeDict)) # Defining fields to be displayed in hover tooltips source = ColumnDataSource( data={ 'x': xVals.flatten(), 'y': yVals.flatten(), 'covValues': covVals.flatten() }) tooltipList = [('xCoord', '@x'), ('yCoord', '@y'), ('Magnitude', '@covValues')] # Defining color map color_mapper = LinearColorMapper(palette=blueRedColors, low=vmin, high=vmax) color_bar = ColorBar(color_mapper=color_mapper, label_standoff=12, border_line_color=None, location=(0,0), ticker=BasicTicker(\ desired_num_ticks=len(blueRedColors))) # Plotting self.logger.info('Determining axis scaling.') if self.scaledRangeDict is not None: plotLabel = FactorRange( factors=[i for i in self.scaledRangeDict.values()], bounds=(0.5, len(self.scaledRangeDict.keys()) + 0.5), factor_padding=0.0, range_padding_units="percent", range_padding=0) else: plotLabel = FactorRange( factors=[str(int(i+1)) \ for i in range(axesLength)], bounds=(0.5, axesLength + 0.5)) self.logger.info('Creating initial figure') # Primary display for directly interacting with the matrices plot = figure(x_range=plotLabel, y_range=plotLabel, tools=TOOLS, toolbar_location='below', tooltips=tooltipList) plot.add_tools(EnhanceTool()) plot.xaxis.major_label_orientation = math.pi / 2 self.logger.info('Creating initial primary plot') plot.rect(x='x', y='y', width=1, height=1, source=source, fill_color={ 'field': 'covValues', 'transform': color_mapper }, line_color=None) plot.title = Title(text='Distance Difference Matrix: ' \ + npyNameList[0], \ align='center') plot.add_layout(color_bar, 'right') # Secondary display for interacting with queued covariance submatrices plot2 = figure(x_range=plotLabel, y_range=plotLabel, tools=TOOLS, toolbar_location='below', tooltips=tooltipList) plot2.add_tools(EnhanceTool()) plot2.xaxis.major_label_orientation = math.pi / 2 source2 = ColumnDataSource( data={ 'x': xVals.flatten(), 'y': yVals.flatten(), 'covValues': [0 for i in covVals.flatten()] }) self.logger.info('Creating initial secondary plot') plot2.rect(x='x', y='y', width=1, height=1, source=source2, fill_color={ 'field': 'covValues', 'transform': color_mapper }, line_color=None) plot2.title = Title(text='Queued Covariance Submatrices', align='center') plot2.add_layout(color_bar, 'right') # Creating a dictionary of distance difference matrices based off of # order they are loaded in self.logger.debug('Creating distance difference matrix mapping') matrixDict = {} for i, npy in enumerate(npyList): if i not in matrixDict.keys(): matrixDict[str(i)] = npyList[i].flatten() # Python Callbacks # ------------------------------------------------------------------ # Takes a flattened matrix and updates the plot to its values def patchMatrixValues(newMatrix, source=source): if (int(self.scale) \ != int(math.ceil(math.sqrt(newMatrix.shape[0])))): newMatrix, indexDict = self.rescaleMatrix( newMatrix, self.scale) newMatrix = newMatrix.flatten() patch_id = [i for i in range(len(source.data['covValues']))] patch = newMatrix source.patch({'covValues': list(zip(patch_id, patch))}) # Slider Callback # Changes the distance difference matrix displayed based off of the index # that the slider is set to def sliderCallback(attr, old, new): plot.x_range.factors = [ str(i) for i in self.scaledRangeDict.values() ] plot.x_range.factors = [ str(i) for i in self.scaledRangeDict.values() ] f = str(new) covValues = source.data['covValues'] axesLength = math.sqrt(len(covValues)) patchMatrixValues(matrixDict[f]) plot.title.text = 'Distance Difference Matrix: ' + npyNameList[new] # Click callback for moving from distance difference matrices to # covariance submatrices def clickCallback(event): plot.x_range.factors = [ str(i) for i in self.scaledRangeDict.values() ] plot.x_range.factors = [ str(i) for i in self.scaledRangeDict.values() ] start_time = time.time() axesLength = math.sqrt(len(source.data['covValues'])) xCoord = math.floor(event.x - 0.5) yCoord = math.floor(event.y - 0.5) # Only accessing covariance submatrix if the click is not along # the diagonal if ((xCoord != yCoord) and (xCoord >= 0) and (xCoord < axesLength + 1) and (yCoord >= 0) and (yCoord < axesLength + 1)): # Handles coordinates "mirrored" across the diagonal if (xCoord > yCoord): temp = xCoord xCoord = yCoord yCoord = temp coordString = '(' + str(xCoord) + ', ' + str(yCoord) + ')' # Handles submatrix access for non-scaled indices subMatrix = None if self.indexDict is None: covIndex = invCovMapDict[coordString] resPairString = '[' + coordString + ']' subMatrix = cSubmatrix.generateSubmatrix( covarianceMatrix, covMapDict, residuePairList=resPairString, allResidues=False, baseDirectory=None).flatten() self.logger.debug('Submatrix for x=' + str(xCoord) \ + ', y=' + str(yCoord) + ': ' \ + str(subMatrix)) # Handles submatrix access for scaled/mapped indices/ranges else: resPairString = '' for xIndex in self.indexDict[xCoord]: for yIndex in self.indexDict[yCoord]: if len(resPairString) > 0: resPairString += ',' resPairString += '(' + str(xIndex) \ + ', ' + str(yIndex) + ')' resPairString = '[' + resPairString + ']' if self.queueState == False: subMatrixList = cSubmatrix.generateSubmatrix( covarianceMatrix, covMapDict, residuePairList=resPairString, allResidues=False, baseDirectory=None, scale=self.scale) subMatrixArray = np.array(subMatrixList) # Multiple submatrices case, takes the average of # given submatrices if len(subMatrixArray.shape) >= 3: subMatrix = np.average(subMatrixArray, axis=0) else: subMatrix = subMatrixList else: self.logger.debug('Appending ' + str(resPairString) \ + ' to queueList') self.queueList.append([ int(xCoord + 1), int(yCoord + 1), str(resPairString) ]) toQueueDiv.text += ' (' + str(xCoord+1) + ','\ + str(yCoord+1)+'),' if self.queueState == False: patchMatrixValues(subMatrix) # Changing plot title name to reflect the covariance pair # with which the covariance submatrix is plotted in respect to xCoord += 1 yCoord += 1 displayString = '(' + str(xCoord) + ', ' + str( yCoord) + ')' plot.title.text = 'Covariance Submatrix: Residue Pair: ' \ + displayString # TODO: When speed comparisons are done, remove the time printouts print('Time to compute submatrix: ' + str(time.time() - start_time)) # Distance Difference Matrix Display Callback # Shows current distance difference matrix if not already shown def ddCallback(event): plot.x_range.factors = [ str(i) for i in self.scaledRangeDict.values() ] plot.x_range.factors = [ str(i) for i in self.scaledRangeDict.values() ] f = str(slider.value) patchMatrixValues(matrixDict[f]) plot.title.text = 'Distance Difference Matrix: ' \ + npyNameList[int(f)] # Reset Button Callback # Resets display to the 0th index distance difference matrix def resetCallback(event): plot.x_range.factors = [ str(i) for i in self.scaledRangeDict.values() ] plot.x_range.factors = [ str(i) for i in self.scaledRangeDict.values() ] slider.value = 0 f = str(slider.value) patchMatrixValues(matrixDict[f]) plot.title.text = 'Distance Difference Matrix: ' \ + npyNameList[0] # Forward Button Callback # Moves DD Index forward by 1 and displays DD matrix def forwardCallback(event): plot.x_range.factors = [ str(i) for i in self.scaledRangeDict.values() ] plot.x_range.factors = [ str(i) for i in self.scaledRangeDict.values() ] if slider.value < len(matrixDict.keys()) - 1: slider.value = slider.value + 1 f = str(slider.value) patchMatrixValues(matrixDict[f]) plot.title.text = 'Distance Difference Matrix: ' \ + npyNameList[int(f)] # Backward Button Callback # Moves DD Index backward by 1 and displays DD matrix def backwardCallback(event): plot.x_range.factors = [ str(i) for i in self.scaledRangeDict.values() ] plot.x_range.factors = [ str(i) for i in self.scaledRangeDict.values() ] if slider.value > 0: slider.value = slider.value - 1 f = str(slider.value) patchMatrixValues(matrixDict[f]) plot.title.text = 'Distance Difference Matrix: ' + npyNameList[ int(f)] # Forward Queue Callback # Moves down the queue to display the next covariance submatrix def forwardQCallback(event): plot.x_range.factors = [ str(i) for i in self.scaledRangeDict.values() ] plot.x_range.factors = [ str(i) for i in self.scaledRangeDict.values() ] if ((self.curQueue is None) and (len(self.queueMatrices) == 0)): return elif ((self.curQueue is None) and (len(self.queueMatrices) >= 0)): self.curQueue = 0 patchMatrixValues(self.queueMatrices[self.curQueue], source2) plot2.title.text = 'Queued Covariance Submatrices: '\ + 'Residue Pair: ' \ + self.queueNameList[self.curQueue] indexDiv.text = 'Index: ' + str(self.curQueue) elif (self.curQueue >= len(self.queueMatrices)): return elif (self.curQueue < (len(self.queueMatrices) - 1)): self.curQueue += 1 print('Acessing curQueue: ' + str(self.curQueue)) print('len(self.queueMatrices): ' + str(len(self.queueMatrices))) patchMatrixValues(self.queueMatrices[self.curQueue], source2) plot2.title.text = 'Queued Covariance Submatrices: '\ + 'Residue Pair: ' \ + self.queueNameList[self.curQueue] indexDiv.text = 'Index: ' + str(self.curQueue) # Backward Queue Callback # Moves up the queue to display the previous covariance submatrix def backwardQCallback(event): plot.x_range.factors = [ str(i) for i in self.scaledRangeDict.values() ] plot.x_range.factors = [ str(i) for i in self.scaledRangeDict.values() ] if ((self.curQueue is None) and (len(self.queueMatrices) == 0)): return elif ((self.curQueue is None) and (len(self.queueMatrices) >= 0)): self.curQueue = 0 patchMatrixValues(self.queueMatrices[self.curQueue], source2) plot2.title.text = 'Queued Covariance Submatrices: '\ + 'Residue Pair: ' \ + self.queueNameList[self.curQueue] indexDiv.text = 'Index: ' + str(self.curQueue) elif (self.curQueue >= len(self.queueMatrices)): return elif (self.curQueue > 0): self.curQueue -= 1 self.logger.debug('Accessing curQueue: ' + str(self.curQueue)) self.logger.debug('len(self.queueMatrices): ' \ + str(len(self.queueMatrices))) patchMatrixValues(self.queueMatrices[self.curQueue], source2) plot2.title.text = 'Queued Covariance Submatrices: '\ + 'Residue Pair: ' \ + self.queueNameList[self.curQueue] indexDiv.text = 'Index: ' + str(self.curQueue) # Queue Button Callback # Toggles queueing mode for residue pairs/ranges def queueCallback(event): # Turning on queuing if self.queueState == False: self.queueState = True toQueueDiv.text = 'Queued Covariance Submatrices:' statusDiv.text = 'Status: Queuing residue pairs' # Turning off queuing and then patching the covariance submatrices # to secondary plot else: self.queueState = False qList = self.queueList self.queueList = [] # TODO: Bokeh doesn't update display until after loop runs statusDiv.text = 'Status: Computing covariance submatrices' for matrixPak in qList: xCoord = int(matrixPak[0]) yCoord = int(matrixPak[1]) resPairString = str(matrixPak[2]) subMatrixArray = np.array( cSubmatrix.generateSubmatrix( covarianceMatrix, covMapDict, residuePairList=resPairString, allResidues=False, baseDirectory=None, scale=self.scale)) # Multiple submatrices case, takes the average of # given submatrices if len(subMatrixArray.shape) >= 3: subMatrix = np.average(subMatrixArray, axis=0) else: subMatrix = subMatrixList self.queueMatrices.append(subMatrix) patchMatrixValues(subMatrix, source2) # Changing plot title name to reflect the covariance pair # with which the covariance submatrix is plotted in respect # to xCoord += 1 yCoord += 1 displayString = '(' + str(xCoord) + ', ' + str( yCoord) + ')' self.queueNameList.append(displayString) plot2.title.text = 'Queued Covariance Submatrix: ' \ + 'Residue Pair: ' \ + displayString computedDiv.text = 'Computed Submatrices: ' \ + str(sorted(set(self.queueNameList))) totalNumberDiv.text = '/' + str(len(self.queueMatrices)) statusDiv.text = 'Status: Submatrix computation complete. Idling' # "Enhances" the selected region by taking the range of residues and # redisplays the plot so it shows only this range of residues at the # given resolution def zoomSelectCallback(event, matrixType="dd"): geometry = event.geometry f = str(slider.value) # Retrieving the boundaries of the rectangular selection # The -0.5 offset accounts for the offset of each square from # the original axis x0 = math.floor(geometry['x0'] - 0.5) x1 = math.floor(geometry['x1'] - 0.5) y0 = math.floor(geometry['y0'] - 0.5) y1 = math.floor(geometry['y1'] - 0.5) # Retrieving the boundaries of the current matrix # (in terms of currently displayed coordinates) sourceDF = source.to_df() xi = min(sourceDF['x']) xf = max(sourceDF['x']) yi = min(sourceDF['y']) yf = max(sourceDF['y']) width = x1 - x0 height = y1 - y0 # Use these values to get information about what scale # the matrix is and is going to be # self.scale # self.covSize -> need to find size for distance difference # matrices and make a separate case for them? # Also need to figure out how to deal with asymmetric boundaries # where width/height are not equal # binSize - the number of units in a given bin axesSize = int(math.sqrt(len(list(matrixDict.values())[0]))) if ((matrixType == "dd") or (matrixType is None)): matrix = matrixDict[str(slider.value)].reshape( axesSize, axesSize) elif (matrixType == "covMatrix"): indexDiv = int(self.curQueue) matrix = self.queueMatrices[indexDiv].reshape( axesSize, axesSize) binSize = int(math.ceil(axesSize / self.scale)) if ((x0 + max(width, height)) <= axesSize / binSize): xUpperBound = x0 + max(width, height) xLowerBound = x0 else: if ((x1 - max(width, height)) >= 0): xUpperBound = x1 xLowerBound = x1 - max(width, height) else: xUpperBound = int(axesSize / binSize) xLowerBound = int(axesSize / binSize - x1) if ((y0 + max(width, height)) <= axesSize / binSize): yUpperBound = y0 + max(width, height) yLowerBound = y0 else: if ((y1 - max(width, height)) >= 0): yUpperBound = y1 yLowerBound = y1 - max(width, height) else: yUpperBound = int(axesSize / binSize) yLowerBound = int(axesSize / binSize - y1) if ((xUpperBound - xLowerBound) > (yUpperBound - yLowerBound)): yUpperBound = xUpperBound yLowerBound = xLowerBound if ((xUpperBound - xLowerBound) < (yUpperBound - yLowerBound)): xUpperBound = yUpperBound xLowerBound = yLowerBound zoomedMatrix = matrix[xLowerBound * binSize:xUpperBound * binSize, yLowerBound * binSize:yUpperBound * binSize] # Modifying axes labels to reflect the zoomedMatrix # Parsing the boundaries to determine the raw index range xIndexMax = int(self.scaledRangeDict[xUpperBound].split('-')[1]) xIndexMin = int(self.scaledRangeDict[xLowerBound].split('-')[0]) yIndexMax = int(self.scaledRangeDict[yUpperBound].split('-')[1]) yIndexMin = int(self.scaledRangeDict[yLowerBound].split('-')[0]) # Partitioning the elements into self.scale number of bins numElements = xIndexMax - xIndexMin xIndexDict = self.partitionIndices(numElements, self.scale, offset=xIndexMin) yIndexDict = self.partitionIndices(numElements, self.scale, offset=yIndexMin) xRangeDict = self.serializeIndexDict(xIndexDict) yRangeDict = self.serializeIndexDict(yIndexDict) plot.x_range.factors = [i for i in xRangeDict.values()] plot.y_range.factors = [i for i in yRangeDict.values()] zoomedMatrix = zoomedMatrix.flatten() patchMatrixValues(zoomedMatrix, source) # ------------------------------------------------------------------ # Creating buttons and linking them to their corresponding callbacks # Buttons to navigate distance difference matrices buttonBack = Button(label="Back", button_type="success") buttonBack.on_event(ButtonClick, backwardCallback) buttonDD = Button(label="Show Distance Difference", button_type="success") buttonDD.on_event(ButtonClick, ddCallback) buttonForward = Button(label="Forward", button_type="success") buttonForward.on_event(ButtonClick, forwardCallback) buttonBar = row(buttonBack, buttonDD, buttonForward) buttonReset = Button(label="Reset", button_type="success") buttonReset.on_event(ButtonClick, resetCallback) # Slider to also navigate distance difference matrices slider = Slider(start=0, end=len(npyList) - 1, value=0, step=1, title="index") slider.on_change('value', sliderCallback) # Zoom button for distance difference matrices/non-queued # covariance submatrices plot.on_event(SelectionGeometry, zoomSelectCallback) plot2.on_event(SelectionGeometry, zoomSelectCallback) # Creating a layout from plot elements self.queueList = [] self.queueState = False self.curQueue = None self.queueMatrices = [] self.queueNameList = [] plot.on_event('tap', clickCallback) # Queue Buttons queueButton = Button(label="Queue", button_type="success") queueButton.on_event(ButtonClick, queueCallback) qBar = row(queueButton) # Buttons to navigate queued covariance submatrices qButtonBack = Button(label="Back", button_type="success") qButtonBack.on_event(ButtonClick, backwardQCallback) qButtonForward = Button(label="Forward", button_type="success") qButtonForward.on_event(ButtonClick, forwardQCallback) qNavBar = row(qButtonBack, qButtonForward) # Div Widgets to show which submatrix is displayed indexDiv = Div(text="""Index: N/A""", \ width=70, height=25) totalNumberDiv = Div(text="""/0""",\ width=100, height=25) indexDivBar = row(indexDiv, totalNumberDiv) # Div Widget to show which residue pairs are queued toQueueDiv = Div(text="""Queued Covariance Submatrices:""", \ width=600, height=50) # Div Widget to show which residue pairs are computed computedDiv = Div(text="""Computed Submatrices:""", \ width=600, height=50) # Div Widget to show statusDiv = Div(text="""Status: Nothing Queued""", \ width=600, height=25) testTitle = Title(text='Test Title', align='center') layout = row( column(plot, qBar, buttonBar, slider, buttonReset), column(plot2, qNavBar, statusDiv, indexDivBar, toQueueDiv, computedDiv)) # Adding the plot to the server's document server_doc = doc server_doc.add_root(layout) server_doc.title = "Distance Difference App"
else: return byRow(source.data['ID'].iloc[source.selected.indices[0]]) menu = [('Publication Paper', 'pub'), ('Dataset', 'data'), ('All', '')] nmenu = RadioButtonGroup(labels=['Publication', 'Dataset', 'Keyword'], active=0) how = ['Jaccard', 'Cosine', 'Hopcroft', 'Adamic-Adar'] nhow = RadioButtonGroup(labels=['Jaccard', 'Cosine', 'Hopcroft', 'Adamic-Adar'], active=0) nhow.on_change('active', lambda attr, old, new: cHow()) search = TextInput(title="Search Archive") rs_search = AutocompleteInput(title="Recommend by Keyword", completions=all_keywords) button = Button(label="Search", button_type="warning") button.on_event(ButtonClick, update) rs_button = Button(label="Recommend", button_type="success") rs_button.on_event(ButtonClick, rs_update) columns = [ TableColumn(field="ID", title="ID", width=20), TableColumn(field="title", title="Title", width=300, formatter=HTMLTemplateFormatter(template=template)), TableColumn(field="description", title="Description", width=200, formatter=HTMLTemplateFormatter(template=template)) ] data_table = DataTable(source=source, columns=columns, width=800) rs_columns = [ TableColumn(field="data_set_id", title="Data ID", width=20), TableColumn(field="rs_score", title="RS Score", width=20), TableColumn(field="rs_title", title="Data Title", width=300, formatter=HTMLTemplateFormatter(template=template)), TableColumn(field="rs_description", title="Data Description", width=100, formatter=HTMLTemplateFormatter(template=template)) ]
from bokeh.events import ButtonClick from bokeh.models import Button button = Button() def callback(event): print('Python:Click') print('in here') button.on_event(ButtonClick, callback)
mapplot.min_border_top = 0 mapplot.sizing_mode = 'scale_both' layout1.children = [ column(row(widgetbox(button), widgetbox(chance_text)), row(widgetbox(text_input), widgetbox(country_text)), row(widgetbox(pre), mapplot, widgetbox(pre))) ] layout2 = tab2_plotting() tabs.tabs = [Panel(child=layout1, title='My luck'), Panel(child=layout2, title='My life')] ### WIDGETS button = Button(label="How lucky am I", width=130) button.on_event(ButtonClick, luck) text_input = TextInput(value="I was born in", title="", width=130) world = data_model.return_world() mapplot = world[world.name == 'Japan'].plot_bokeh( figsize=(900, 600), simplify_shapes=5000, xlim=(-170, 170), ylim=(-40, 70), show_colorbar=False, color='white', line_color='white', tile_provider='CARTODBPOSITRON', show_figure=False, toolbar_location=None, xlabel=None,
slider = Slider(start=years[0], end=years[-1], value=years[0], step=1, title="Year") slider.on_change('value', slider_update) callback_id = None def animate(): global callback_id if button.label == '► Play': button.label = '❚❚ Pause' callback_id = curdoc().add_periodic_callback(animate_update, 200) else: button.label = '► Play' curdoc().remove_periodic_callback(callback_id) button = Button(label='► Play', width=60) button.on_event('button_click', animate) layout = layout([ [plot], [slider, button], ], sizing_mode='scale_width') curdoc().add_root(layout) curdoc().title = "Gapminder"
""" def create_hover_tool(list_of_keys): tooltips = [('date', '@date{%F %T}')] + [(s, '@' + s) for s in list_of_keys] return HoverTool(tooltips=tooltips, formatters={'@date': 'datetime'}, mode='mouse') remote_ip_text = TextInput(title="Remote IP", value=DEFAULT_REMOTE_IP) self_ip_text = TextInput(title="Self IP", value=DEFAULT_SELF_IP) route_button = Button(label="Route telemetry") route_button.on_event(ButtonClick, route_telemetry_command) raw_command_text = TextInput(title="Raw command (hex)") send_raw_command_button = Button(label="Send raw command") send_raw_command_button.on_event(ButtonClick, send_raw_command) command_info_div = Div(text="") command_block = column(remote_ip_text, self_ip_text, route_button, raw_command_text, send_raw_command_button, command_info_div) gps_info_div = Div(text="") pps_info_div = Div(text="")
def main(): # set up main bokeh figure p = figure(x_range=(0, 10), y_range=(0, 10), tools=[], title='Draw points in the network') p.background_fill_color = 'lightgrey' # start off with sample points and their associated flows source = ColumnDataSource({ 'x': [2, 7, 5, 8], 'y': [2, 2, 6, 1], 'flow': ['-2', '-5', '8', '-1'] }) renderer = p.scatter(x='x', y='y', source=source, color='blue', size=10) columns = [ TableColumn(field="x", title="x"), TableColumn(field="y", title="y"), TableColumn(field='flow', title='flow') ] table = DataTable(source=source, columns=columns, editable=True, height=200) draw_tool = PointDrawTool(renderers=[renderer], empty_value='1') p.add_tools(draw_tool) p.toolbar.active_tap = draw_tool titletextbox = Div( text= "<h2>Objective: minimize construction cost of network<p>Construction cost is based on number of pipes and distance between nodes.<br>Additional constraints imposed: flows in network must be balanced.<br></h2>", width=1100, height=150) textbox = Div(text="", width=200, height=100) floating = 1. fixed = 0. button = Button(label='Solve Network') button.on_event( ButtonClick, partial(button_click_event, source=source, textbox=textbox, figure=p)) p.on_event( PanEnd, partial(button_click_event, source=source, textbox=textbox, figure=p)) # set up sliders lumpSumCost = Slider(title="Fixed cost pipe", value=0.0, start=0.0, end=500.0, step=50) floatingCost = Slider(title="Floating cost pipe", value=1.0, start=0.0, end=500.0, step=10.) for w in [lumpSumCost, floatingCost]: w.on_change( 'value', partial(update_data, source=source, textbox=textbox, figure=p, lumpSumCost=lumpSumCost, floatingCost=floatingCost)) # create page layout curdoc().add_root( Column( titletextbox, Row(Column(p, table, width=800), Column(lumpSumCost, floatingCost, button, textbox, width=300)))) curdoc().title = "Network"
Evalue l'ensemble des filtres actifs """ yearChoose = f_year.active etatChoose = f_etat.active quartierChoose = f_quartier.active df_data.query(yearChoose, etatChoose, quartierChoose) bd_source.data.update(df_data.bd.to_dict(orient='list')) qt_source.data.update(df_data.qt.to_dict(orient='list')) pj_source.data.update(df_data.proj.to_dict(orient='list')) et_source.data.update(df_data.etat.to_dict(orient='list')) f_year.on_change('active', update) f_etat.on_change('active', update) f_quartier.on_change('active', update) f_reset.on_event(ButtonClick, reset) ########################## GRAPHS ######################### g_map = mapPlot(bd_source, qt_source) g_bar = barPlot(pj_source) g_stack = stackPlot(et_source) graphs = column(g_map, row(g_bar, g_stack, sizing_mode="stretch_width"), sizing_mode="stretch_width") ########################## LAYOUT ######################### layout = column(m_header, row(sidebar, graphs, m_blank),