def createSnakeControls(self): #snake mode controls snakeModeControls = RadioButtonGroup(labels=["Square", "LED"], active=0, width=400, button_type="primary") # snakeModeControls.on_change("active",self.visibilityCallback) self.snakeSpeed = 500 snakeSpeedSlider = Slider(title="Speed", show_value=False, value=self.snakeSpeed, start=30, end=1000, step=5) snakeSpeedSlider.on_change("value", self.snakeSpeedCallback) snakeNumberControls = RadioButtonGroup(labels=["1", "2"], active=0, width=400, button_type="primary", name="Num Snakes") snakeColorWindow = self.createColorOutputWindow(2) sendSnakeButton = Button(label="Send") sendSnakeButton.on_click(self.postSnake) return [ snakeModeControls, snakeNumberControls, snakeSpeedSlider, snakeColorWindow, sendSnakeButton ]
def init(self, doc): # Source must only be modified through a stream self.source = ColumnDataSource(data=self.data) self.colors[0] = 'cyan' #self.source = ColumnDataSource(data=self.data[self.scale]) # Enable theming theme = Theme( os.path.dirname(os.path.abspath(__file__)) + '/theme.yaml') doc.theme = theme self.doc = doc fig = figure(plot_width=600, plot_height=400, tools='xpan,xwheel_zoom, xbox_zoom, reset, save', title=self.title, x_axis_label=self.XAXIS, y_axis_label=self.ylabel) # Initialize plots for i, key in enumerate(self.keys): fig.line(source=self.source, x=self.x, y=key, color=self.colors[i], line_width=LINE_WIDTH, legend_label=key) band = Band(source=self.source, base=self.x, lower=key + 'lower', upper=key + 'upper', level='underlay', line_color=self.colors[i], line_width=1, line_alpha=0.2, fill_color=self.colors[i], fill_alpha=0.2) fig.add_layout(band) def switch_scale(attr, old, new): """Callback for RadioButtonGroup to switch tick scale and refresh document Args: attr: variable to be changed, in this case 'active' old: old index of active button new: new index of active button """ self.scale = self.scales[new] self.source.data = self.data[self.scale] self.timescales = RadioButtonGroup( labels=[str(scale) for scale in self.scales], active=self.scales.index(self.scale)) self.timescales.on_change('active', switch_scale) self.structure = layout([[self.timescales], [fig]]) self.doc.add_root(self.structure) self.fig = fig
def __init__(self): self.WIDTH_MATRIX = 1 self.HEIGHT_MATRIX = 1 self.tabs = RadioButtonGroup(labels=['Page1', 'Page2'], active=0) self.tabs.on_change('active', lambda attr, old, new: self.change_page()) self.data_directory = 'data' self.data_files = os.listdir(self.data_directory) self.select_data_files1 = Select(title="Data files 1:", value="df1", options=["df1"] + self.data_files) self.select_data_files2 = Select(title="Data files 2:", value="df2", options=["df2"] + self.data_files) self.select_data_files1.on_change( 'value', lambda attr, old, new: self.init_dataframes()) self.select_data_files2.on_change( 'value', lambda attr, old, new: self.init_dataframes()) self.refresh_button = Button(label="Refresh", button_type="success", width=100) self.refresh_button.on_click(self.update_directory) self.layout = column( self.tabs, row(self.select_data_files1, self.select_data_files2), self.refresh_button) curdoc().add_root(self.layout)
def createControls(self): delta_pres = (self.max_pres - self.min_pres) / (self.plot_scale - 1) delta_sat = 1.0 / (self.plot_scale - 1) self.slidePres = Slider(start=self.min_pres, end=self.max_pres, value=self.min_pres + (self.max_pres - self.min_pres), step=delta_pres, title='Constant Pressure', callback_policy='mouseup') self.slideSat = Slider(start=0, end=1, value=0.5, step=delta_sat, title='Constant Saturation', callback_policy='mouseup') self.radioAbsRel = RadioButtonGroup(labels=['Absolute', 'Relative'], active=1) self.buttonReset = Button(label='Reset Initial Conditions') self.slidePres.on_change('value', self.updateCPres) self.slideSat.on_change('value', self.updateCSat) self.radioAbsRel.on_change('active', self.toggleAbsRel) self.buttonReset.on_click(self.clickReset)
class SimulOptimWidget: def __init__(self, target, simul_df, possible_targets, var_influyentes, periodo, ranges, periodo_custom_start, periodo_custom_end): self.simulate_wb = DynamicSimulWidget( target=target, df=simul_df, periodo=periodo, periodo_custom_start=periodo_custom_start, periodo_custom_end=periodo_custom_end) # self.optimize_wb = DynamicOptimWidget(target=target, possible_targets=possible_targets, var_influyentes=var_influyentes, ranges=ranges) self.optimize_wb = create_optim_div(target=target, possible_targets=possible_targets, var_influyentes=var_influyentes, ranges=ranges) self.wb = widgetbox([self.simulate_wb.wb], sizing_mode='stretch_width', max_width=690) self.rb = RadioButtonGroup(labels=['Simular', 'Optimizar'], height=35, active=0, min_width=690, max_width=690) self.rb.on_click(self.select_simul_optim) def select_simul_optim(self, new): if new == 0: self.wb.children = [self.simulate_wb.wb] else: self.wb.children = [self.optimize_wb]
def add_coaddcam(self, plots): #----- #- Highlight individual-arm or camera-coadded spectra coaddcam_labels = ["Camera-coadded", "Single-arm"] self.coaddcam_buttons = RadioButtonGroup(labels=coaddcam_labels, active=0) self.coaddcam_callback = CustomJS( args = dict(coaddcam_buttons = self.coaddcam_buttons, list_lines=[plots.data_lines, plots.noise_lines, plots.zoom_data_lines, plots.zoom_noise_lines], alpha_discrete = plots.alpha_discrete, overlap_bands = plots.overlap_bands, alpha_overlapband = plots.alpha_overlapband), code=""" var n_lines = list_lines[0].length for (var i=0; i<n_lines; i++) { var new_alpha = 1 if (coaddcam_buttons.active == 0 && i<n_lines-1) new_alpha = alpha_discrete if (coaddcam_buttons.active == 1 && i==n_lines-1) new_alpha = alpha_discrete for (var j=0; j<list_lines.length; j++) { list_lines[j][i].glyph.line_alpha = new_alpha } } var new_alpha = 0 if (coaddcam_buttons.active == 0) new_alpha = alpha_overlapband for (var j=0; j<overlap_bands.length; j++) { overlap_bands[j].fill_alpha = new_alpha } """ ) self.coaddcam_buttons.js_on_click(self.coaddcam_callback)
def add_widgets(self): self.stream_option = RadioButtonGroup(labels=['EEG', 'ACC', 'GYR'], active=0) self.filter_option = RadioButtonGroup( labels=['Low Pass', 'High Pass', 'Band Pass'], active=0) self.widget_box = widgetbox(self.stream_option, self.filter_option, width=300)
def __init__(self): # extend __init__ super class IPlugin.__init__(self) # instantiate main components self.tx = TxData() self.prod_master = ProductMaster() self.cust_master = CustomerMaster() self.quote = Quote() self.price_model = PriceModel() # cds_plot lives here rather than quote because they draw on several main components self.cds_plot = ColumnDataSource(data=dict(x=[0], y=[0], attr_label=[''], attr_name=[''])) # plot_filters lives here because it's drawing from several main components self.plot_filters = [MultiSelect(title='Product_filter', value=[''], options=[''])] self.plot_filters[0].on_change('value', self.update_plot) # configuration backup settings self.backup_loc = TextInput(value=getcwd()) self.backup_config_button = Button(label='Output config', button_type='success') self.backup_config_button.on_click(self.output_config) self.config_data_input = FileInput(accept=".json") self.config_data_input.on_change('value', self.load_config) self.datafile_selector = RadioButtonGroup(labels=['Tx data', 'Product master', 'Customer master'], active=0) self.datafile_selector.on_change('active', self.refresh_view) # define and initialize views (and their layout attributes) self.view_quote = QuoteView(self) self.view_price_mgt = PriceMgtView(self) self.view_price_model_config = PriceModelConfigView(self) self.view_attr_settings = AttrSettingsView(self) self.view_settings = SettingsView(self) self.tabs = Tabs( tabs=[Panel(child=self.view_quote.layout, title='Quote'), Panel(child=self.view_price_mgt.layout, title='Price Management'), Panel(child=self.view_price_model_config.layout, title='Price adjustments'), Panel(child=self.view_attr_settings.layout, title='Attribute Settings'), Panel(child=self.view_settings.layout, title='Settings')]) # define some on_change events self.price_model.price_group_selector.on_change('active', self.refresh_view) self.price_model.num_prod_groups.on_change('value', self.refresh_view, self.update_on_change) self.price_model.num_customer_groups.on_change('value', self.refresh_view) self.tx.num_columns.on_change('value', self.refresh_view) self.prod_master.num_columns.on_change('value', self.refresh_view) self.cust_master.num_columns.on_change('value', self.refresh_view) for pg in self.price_model.price_groups: pg.num_attributes.on_change('value', self.refresh_view, self.update_on_change) for attr in pg.attributes: attr.sourcefile.on_change('value', partial(attr.update_sourcecolumns_options, cpq=self)) attr.num_configs.on_change('value', self.refresh_view, self.update_on_change, self.update_quote_filters)
def build_filter_controls(options): server_names = options['server_names'] server_select = RadioButtonGroup(labels=server_names, active=0) year_select = RangeSlider(start=options['year-start'], end=options['year-end'], value=(options['year-start'], options['year-end']), step=1) #, title="Year") month_select = MultiSelect(title="Month:", value=['0'], options=options['month']) day_select = RangeSlider(start=1, end=31, value=(1, 31), step=1) ###, title="Day") day_week_select = CheckboxButtonGroup( #title='Dia da semana', labels=options['day_week']) #, #active=[i for i in range(len(options['day_week']))]) time_select = RangeSlider(start=0, end=24, value=(0, 24), step=1, title="Period") scale_select = RadioButtonGroup(labels=querys.scale, active=0) def select_data(): print('data select') server_name = server_names[server_select.active] months = month_select.value days = day_select.value day_week = day_week_select.active years = year_select.value time = time_select.value scale = querys.scale_str[scale_select.active] db = database.db sql = build_query(server_name, scale, years, months, days, day_week, time) print(sql) # return pd.io.sql.read_sql(sql, db) return [ server_select, scale_select, year_select, month_select, day_select, day_week_select, time_select ], select_data
def build_dashboard(path: Path, num_queries=1000): output_file(str(path / 'dashboard.html')) data = pd.read_csv(str(path / 'overall_metrics.csv'), index_col=0, dtype={ 'dataset': str, 'click_model': str, 'online_benchmark': np.float64, 'offline_benchmark': np.float64, 'online_mean@10': np.float64, 'online_std@10': np.float64, 'offline_mean @ 10': np.float64, 'offline_std @ 10': np.float64 }) COLOR_MAPPING = dict(zip(data.dataset.unique(), Category10[9])) data['color'] = data.dataset.map(COLOR_MAPPING) data['lower_offline'] = data['offline_mean@10'] - data['offline_std@10'] data['upper_offline'] = data['offline_mean@10'] + data['offline_std@10'] data['lower_online'] = data['online_mean@10'] - data['online_std@10'] data['upper_online'] = data['online_mean@10'] - data['online_std@10'] data['y'] = data['offline_mean@10'] data['x'] = data.index.values source = ColumnDataSource(data) view = CDSView(source=source, filters=DEFAULT_FILTERS) TOOLS = "pan,wheel_zoom,box_zoom,reset,save" hover = HoverTool(tooltips=[("NDCG@10", "$y")]) p = figure(tools=TOOLS, x_range=(0, num_queries), y_range=(0, 1)) p.add_tools(hover) p.line(x='x', y='y', source=source, view=view, line_color=data.color.iloc[0], legend='GA-TDM') p.line(x='x', y='online_benchmark', source=source, view=view, line_color='red', legend='MGD-19') p.line(x='x', y='offline_benchmark', source=source, view=view, line_color='black', legend='MGD-19') # Widgets # Evaluation mode eval_mode_rb = RadioButtonGroup(labels=['Offline', 'Online'], active=0, callback=change_eval_mode(source, p, view)) # Click model click_model_rb = RadioButtonGroup(labels=['Perfect', 'Navigational', 'Informational'], active=0, callback=change_cm(view)) # Dataset dataset_select = Select(title="Dataset", value="HP2003", options=list(data.dataset.unique()), callback=change_ds(view)) # Legend p.legend.location = 'top_left' wb = widgetbox([eval_mode_rb, click_model_rb, dataset_select]) save(column([wb, p]))
def _doc_modifier(doc: Document) -> None: plot, source = _create_plot(stats, aspects) events_table = _create_events_table() events_type = RadioButtonGroup(labels=['All Events', 'In-Domain Events'], active=0) # pylint: disable=unused-argument def _events_handler(attr, old, new): _update_events(stats, aspects, events_table, source, events_type.active) events_type.on_change('active', _events_handler) source.selected.on_change('indices', _events_handler) # pylint: disable=no-member doc.add_root(column(_create_header(), plot, events_type, events_table, sizing_mode="scale_width"))
def classification_tab(): pairs = [["stackoverflow.com", "academia.stackexchange.com"],["stackoverflow.com", "softwareengineering.stackexchange.com"]] # pretrained classification models nbsoac = load("app/models/10k_so_ac_bayes_model.joblib") nbsose = load("app/models/10k_so_se_bayes_model.joblib") svmsoac = load("app/models/10k_so_ac_SVM_model.joblib") svmsose = load("app/models/10k_so_se_SVM_model.joblib") learning_type = RadioButtonGroup(labels=["Bayes", "Support Vector Machine"], active=0) site_pair = RadioButtonGroup(labels=["Stack Overflow/Academia", "Stack Overflow/Software Engineering"], active=0) tai = TextAreaInput(value="", rows=6, title="Enter a post message:") predict = Button(label="Predict", button_type="success") p = Paragraph(text="""Your Site Prediction will be displayed here""", width=300, height=50) def make_prediction(): lt = learning_type.active sp = site_pair.active model = None if lt == 0: if sp == 0: model = nbsoac else: model = nbsose else: if sp == 0: model = svmsoac else: model = svmsose prediction = model.predict([tai.value])[0] p.text = "Message belongs to site: " + pairs[sp][prediction - 1] predict.on_click(make_prediction) # Put controls in a single element controls = WidgetBox(learning_type, site_pair, tai, predict, p) # Create a row layout layout = row(controls) tab = Panel(child=layout, title='Message Site Classification') return tab
def enable_interaction(self): radiokeys = list(self._scatters.keys()) self._which_scatter = RadioButtonGroup(labels=radiokeys, active=0) data_sources = { key: scatter.data_source for key, scatter in self._scatters.items() } js_argdict = f"""{{ { ','.join(f"{i}: {k}" for i, k in enumerate(radiokeys)) } }}""" self.figure.js_on_event('tap', CustomJS( args=dict(which_scatter=self._which_scatter, **data_sources), code=f""" var argdict = {js_argdict}; var scatter = argdict[which_scatter.active]; var data = {{ 'x': scatter.data.x, 'y': scatter.data.y }}; data['x'].push(cb_obj['x']); data['y'].push(cb_obj['y']); scatter.data = data; scatter.change.emit(); """ )) for source_name, data_source in data_sources.items(): self.register_state_attribute(source_name, data_source, 'data', prefix=['inputs'])
def get_layout_query(self): heading_text="A program that displays every episode's rating for the tv_series." heading=Paragraph(text=heading_text,width=400) self.Search = Button(label="Search") self.btnGroupchoose = RadioButtonGroup(name='choose', labels=["By imdbID", "By Title"], active=0) paragraph = Paragraph(text="Search way") self.Parameter_input = TextInput(value="", title="ID or Title:", placeholder="ID or Title") self.select = Select(title="Season:", value="None", options=["None"]) self.Status=Paragraph(text="Status:",width=200) self.Tvtext=Paragraph(text="Tv:",width=200) self.Seasontext=Paragraph(text="Season:",width=200) x=[] y=[] source = ColumnDataSource(data=dict(x=x, y=y)) p = figure(x_range=x,plot_height=400,title="Season rating", toolbar_location=None, tools="") p.line('x', 'y', source=source, line_width=3, line_alpha=0.6) p.xaxis.major_label_orientation = 1 self.Search.on_click(self.search_click) self.select.on_change('value',self.select_click) self.layout_query = layout( [ [heading], [[widgetbox(paragraph, width=100),widgetbox(self.btnGroupchoose)], [widgetbox(self.Parameter_input)], [widgetbox(self.Search, width=100)],], [[self.Status,self.Tvtext,self.Seasontext],self.select], p ] )
def create(cls): """One-time creation of app's objects. This function is caalled once, and is responsible for creating all objects (plots, datasources, etc) """ obj = cls() obj.utc_button = RadioButtonGroup(labels=["local time", "UTC"], active=cs.utc_start) obj.source_data_range = ColumnDataSource(data=dict(x=[], y=[])) obj.p_manager.create(obj.source_data_range) obj.plot_weather = obj.p_manager.plot_weather obj.plot_ceil = obj.p_manager.plot_ceil obj.plot_data_range = obj.p_manager.plot_data_range obj.plot_ceil.x_range = obj.plot_weather.x_range obj.children.append(obj.utc_button) obj.children.append(obj.plot_data_range) obj.children.append(obj.plot_ceil) obj.children.append(obj.plot_weather) if cs.utc_start == 0: print 'changing to utc ' sys.stdout.flush() obj.p_manager.shift_time(obj, 0) return obj
def __init__(self, options_list, risk_free_rate, iv): self.options = options_list self.r = risk_free_rate self.iv = iv self.curr_iv = iv self.t = datetime.today() self.expiry_t = self.options[0].expiration self.x_vector = None self.min_strike = None self.max_strike = None # Widgets self.right_radio = RadioButtonGroup(labels=["Calls", "Puts"], active=0) self.expiry_slider = Slider(title="Days to exp.", value=0.0, start=-5.0, end=5.0, step=1) self.iv_slider = Slider(title="IV", value=self.curr_iv, start=0.0, end=1.0, step=0.01) self.restore_iv_button = Button(label="Restore IV")
def make_input_widgets(self): """Define the widgets to select dataset, verification package, metrics and period """ self.datasets_widget = Select(title="Dataset:", value=self.selected_dataset, options=self.datasets['datasets']) self.filters_widget = Select(title="Filter:", value=self.selected_filter, options=self.filters) self.packages_widget = Select(title="Verification package:", value=self.selected_package, options=self.packages['packages']) self.metrics_widget = Select(title="Metric:", value=self.selected_metric, options=self.metrics['metrics']) active = self.periods['periods'].index(self.selected_period) self.period_widget = RadioButtonGroup(labels=self.periods['periods'], active=active)
def __init__(self, logdata: DataFrame): self.line_dataset = None self.scatter_dataset = None self.logdata = logdata # Partition markers, filter out span data from full log self.span_locations = logdata[logdata.Name.isin(conf.sections)] self.logdata = self.logdata[~self.logdata.Name.isin(conf.sections)] # Convert to datetime format self.logdata.Timestamp = to_datetime(self.logdata.Timestamp, unit='ms') # Scatter data self.scatter_data = self.logdata # Multi line data prep self.line_data = self.logdata.groupby('Channel').aggregate({ 'Timestamp': list, 'Value': list }) self.id_list = list(self.line_data.index) self.id_list.sort() self.line_checkbox = CheckboxGroup(labels=self.id_list) self.line_checkbox.on_change('active', self.lineplot_handler) self.scatter_checkbox = CheckboxGroup(labels=self.id_list) self.scatter_checkbox.on_change('active', self.scatterplot_handler) #self.duration = self.logdata.Timestamp.max() - self.reaction_times = [1, 2, 3, 4, 5] self.extra_data_text = PreText(text='') try: self.sections = generate_sections(logdata) radio_labels = [ 'Section %s' % i for i in range(len(self.sections)) ] radio_labels.append('All') self.radio_buttons = RadioButtonGroup(labels=radio_labels, active=len(radio_labels) - 1) self.radio_buttons.on_change('active', self.radio_button_handler) except IndexError: print('Missing Slide values. Skipping section generation') self.radio_buttons = RadioButtonGroup(labels=['Fix your data'])
def add_count_toggle(plot): from bokeh.layouts import widgetbox from bokeh.models import (CustomJS, Column, Circle, Rect, ColumnDataSource, LinearColorMapper, ColorBar, Label) from bokeh.models.widgets import RadioButtonGroup args = dict( circle=None, rect=None, ) for r in plot.references(): if isinstance(r, Circle): args['circle'] = r elif isinstance(r, Rect): args['rect'] = r elif isinstance(r, LinearColorMapper): args['cmapper'] = r elif isinstance(r, ColorBar): args['cbar'] = r elif isinstance(r, ColumnDataSource): args['ds'] = r elif isinstance(r, Label): args['title'] = r callback = CustomJS(args=args, code=""" var label = cb_obj.labels[cb_obj.active]; var selection = {Observations: 'count', Subjects: 'subjects'}[label]; if (circle !== null) {circle.fill_color.field = selection}; if (rect !== null && rect.fill_color) {rect.fill_color.field = selection }; var max_val = Math.max.apply(null, ds.data[selection]); cmapper.high = max_val; cbar.ticker.ticks = [0, max_val]; split_title = title.text.split(' '); split_title[2] = label.toLowerCase(); title.text = split_title.join(' '); ds.trigger("change"); """) plot.min_border_top = 50 radio_button_group = RadioButtonGroup(labels=["Observations", "Subjects"], active=0) radio_button_group.callback = callback widgets = widgetbox(radio_button_group, width=300) return Column(widgets, plot)
def modify_doc(self, doc): # checkboxes for groups self.group_selection_add = CheckboxGroup(labels=self.group_ids, active=[0, 1]) self.group_selection_add.on_change('active', self.update_add) initial_groups = [i + 1 for i in self.group_selection_add.active] # radio button for data type self.type_selection_add = RadioButtonGroup( labels=["Prior", "After", "Diff"], active=0) self.type_selection_add.on_change('active', self.update_add) initial_type = self.type_selection_add.active # add control and initialize display controls = WidgetBox(self.group_selection_add, self.type_selection_add) self.sources_add = self.make_dataset_add(initial_groups, initial_type) # add two panels, one for adding p = self.make_plot(self.sources_add, True) layout = row(controls, p) tab1 = Panel(child=layout, title='Add') # # checkboxes for groups # self.possible_groups = list(combinations([1,2,3], 2)) # labels = [] # for pg in self.possible_groups: # labels.append(self.group_ids[pg[0]] + ' vs ' + self.group_ids[pg[1]]) # self.group_selection_comp = RadioButtonGroup(labels=labels, active=0) # self.group_selection_comp.on_change('active', self.update_comp) # initial_groups = self.possible_groups[self.group_selection_comp.active] # # radio button for data type # self.type_selection_comp = RadioButtonGroup(labels=["Prior", "After", "Diff"], active=0) # self.type_selection_comp.on_change('active', self.update_comp) # initial_type = self.type_selection_comp.active # # add control and initialize display # controls = WidgetBox(self.group_selection_comp, self.type_selection_comp) # self.sources_comp = {} # for i, g in enumerate(self.group_ids): # # for initialization only # self.sources_comp[g] = self.make_dataset_add([i], initial_type) # # add two panels, one for adding # p = self.make_plot(self.sources_comp, False) # layout = row(controls, p) # tab2 = Panel(child=layout, title = 'Compare') # Make a tab with the layouts tabs = Tabs(tabs=[tab1]) doc.add_root(tabs)
def __init__(self, name='', pg_type='Product'): self.name = TextInput(value=name, width=250) self.pg_type = pg_type self.num_attributes = Spinner(title="Number of attributes", low=1, high=100, step=1, value=1, width=150) self.num_attributes.on_change('value', self.update_attributes, self.update_attribute_selector) self.attributes = [Attribute()] self.attribute_selector = RadioButtonGroup(labels=['Attribute #1'], active=0)
def use_server_with_radio_buttons(self): # crate columndatasource source = ColumnDataSource( dict(average_grades=["B+", "A", "D-"], exam_grades=["A+", "C", "D"], student_names=["Stephan", "Helder", "Riazudidn"])) # create the figure f = figure(x_range=[ "F", "D-", "D", "D+", "C-", "C", "C+", "B-", "B", "B+", "A-", "A", "A+" ], y_range=[ "F", "D-", "D", "D+", "C-", "C", "C+", "B-", "B", "B+", "A-", "A", "A+" ]) # add labels for glyphs labels = LabelSet(x="average_grades", y="exam_grades", text="student_names", x_offset=5, y_offset=5, source=source) f.add_layout(labels) # create glyphs f.circle(x="average_grades", y="exam_grades", source=source, size=8) # create function def update_labels(attr, old, new): labels.text = options[radio_button_group.active] # create select widget options = ["average_grades", "exam_grades", "student_names"] radio_button_group = RadioButtonGroup(labels=options) radio_button_group.on_change("active", update_labels) # create layout and add to curdoc lay_out = layout([[radio_button_group]]) curdoc().add_root(f) curdoc().add_root(lay_out)
def add_vi_quality(self, viewer_cds, widgets): #- Main VI quality widget self.vi_quality_input = RadioButtonGroup(labels=self.vi_quality_labels) vi_quality_code = self.js_files["CSVtoArray.js"] + self.js_files["save_vi.js"] vi_quality_code += """ if ( vi_quality_input.active >= 0 ) { cds_metadata.data['VI_quality_flag'][ifiberslider.value] = vi_quality_labels[vi_quality_input.active] } else { cds_metadata.data['VI_quality_flag'][ifiberslider.value] = "-1" } autosave_vi_localStorage(output_file_fields, cds_metadata.data, title) cds_metadata.change.emit() """ self.vi_quality_callback = CustomJS( args = dict(cds_metadata = viewer_cds.cds_metadata, vi_quality_input = self.vi_quality_input, vi_quality_labels = self.vi_quality_labels, ifiberslider = widgets.ifiberslider, title=self.title, output_file_fields = self.output_file_fields), code=vi_quality_code ) self.vi_quality_input.js_on_click(self.vi_quality_callback)
def source_filters(sources): def _handle_state_filter(): for fullname in sources['dataframes']: df = sources['dataframes'][fullname] df = df[(df.index >= _state['date_range'][0]) & (df.index <= _state['date_range'][1])] units = UNIT_CONVERSION_MAP[_state['units']] df = df * UNIT_CONVERSION[units] sources['sources'][fullname].data = ColumnDataSource(df).data for callback in ELEMENT_CALLBACKS: callback(sources=sources, **_state) def _date_slider_handler(attr, old, new): start_time, end_time = new start_date = dt.datetime.fromtimestamp(start_time / 1000) end_date = dt.datetime.fromtimestamp(end_time / 1000) _state['date_range'] = (start_date, end_date) _handle_state_filter() start_date = dt.datetime(year=2018, month=12, day=1) end_date = dt.datetime(year=2018, month=12, day=1) date_slider = DateRangeSlider(start=_state['date_range'][0], end=_state['date_range'][1], value=_state['date_range'], step=1, title="Date Range", height=100) date_slider.on_change('value', _date_slider_handler) def _radio_button_group_handler(attr, old, new): _state['units'] = int(new) _handle_state_filter() radio_button_group = RadioButtonGroup(labels=UNIT_CONVERSION_MAP, active=0, width=700, height=100) radio_button_group.on_change('active', _radio_button_group_handler) div_button_group_selection = Div(text=f'<img src="/visualization/static/images/{UNIT_CONVERSION_MAP[_state["units"]]}.svg" height="100px"/>', height=100) def _update_div_button_group(**kwargs): units = UNIT_CONVERSION_MAP[kwargs['units']] div_button_group_selection.text = f'<img src="/visualization/static/images/{units}.svg" height="100px"/>' ELEMENT_CALLBACKS.append(_update_div_button_group) return [date_slider, radio_button_group, div_button_group_selection]
def __init__(self): self.WIDTH_MATRIX = WIDTH_MATRIX self.HEIGHT_MATRIX = HEIGHT_MATRIX self.DATA_DIRIRECTORY = DATA_DIR self.plots_rock = column() self.source_correlation_plot = None self.select_plots = [] self.view_model = views.ViewModel.ViewModel() self.data_files = os.listdir(self.DATA_DIRIRECTORY) self.my_data_frames = models.MyDataFrames.MyDataFrames() self.Y_COL = self.my_data_frames.get_name_dept() self.tabs = RadioButtonGroup(labels=['Page1', 'Page2'], active=0) self.tabs.on_change('active', lambda attr, old, new: self.change_page()) self.select_data_files1 = Select(title="Data files 1:", value="df1", options=["df1"] + (self.data_files)) self.select_data_files2 = Select(title="Data files 2:", value="df2", options=["df2"] + (self.data_files)) self.select_data_files1.on_change( 'value', lambda attr, old, new: self.change_dataframes()) self.select_data_files2.on_change( 'value', lambda attr, old, new: self.change_dataframes()) self.refresh_button = Button(label="Refresh", button_type="success", width=100) self.refresh_button.on_click(self.update_directory) self.plot_matrix = views.PlotMatrix.PlotMatrix() self.layout = column( self.tabs, row(self.select_data_files1, self.select_data_files2), self.refresh_button) curdoc().add_root(self.layout)
def show_analysis() -> None: global stats, aspects, plot, source, tabs plot, source = _create_plot() events_table = _create_events_table() # pylint: disable=unused-argument def _events_handler(attr, old, new): _update_events(events_table, events_type.active) # Toggle display of in-domain / All aspect mentions events_type = RadioButtonGroup(labels=["All Events", "In-Domain Events"], active=0) analysis_layout = layout([[plot], [events_table]]) # events_type display toggle disabled # analysis_layout = layout([[plot],[events_type],[events_table]]) analysis_tab = Panel(child=analysis_layout, title="Analysis") tabs.tabs.insert(2, analysis_tab) tabs.active = 2 events_type.on_change("active", _events_handler) source.selected.on_change("indices", _events_handler) # pylint: disable=no-member
def bkapp(doc): def update_plot(attrname, old_value, new_value): disease = disease_selector.value smooth = int(smooth_selector.value) src = models.get_disease_totals_by_name(disease, smooth) source.data.update(src.data) chart.title.text = disease disease_selector.label = disease smooth_selector.label = str(smooth) doc.title = "Epidemic - {}".format(disease) # request args = doc.session_context.request.arguments get_param = lambda param, default: args.get( param, [bytes(str(default), encoding='utf')])[0].decode('utf-8') disease = get_param('disease', DEFAULT_DISEASE) smooth = get_param('smooth', 2) ## Components # Widgets disease_selector = Dropdown(label=disease, value=disease, menu=list(zip(DISEASES, DISEASES))) smooth_selector = Dropdown(label=smooth, value=smooth, menu=[(str(i), str(i)) for i in range(1, 9)]) picker = RadioButtonGroup(labels=['Total Cases', 'Cases by Region'], width=300) # Sources source = ColumnDataSource( ) # models.get_disease_data_by_name(disease,smooth) # Events disease_selector.on_change('value', update_plot) smooth_selector.on_change('value', update_plot) # Figures chart = make_plot(source, disease) ranger = make_range_tool(chart) chart_range = make_range_plot(source, ranger) # controls = column(widgetbox(disease_selector, smooth_selector, picker), height=280) charts_col = column(chart, chart_range, width=1024) doc.add_root(row(charts_col, controls)) doc.title = "Epidemic - {}".format(disease) update_plot(None, None, None)
def _init_controls(self): """Initialize all controls in the dashboard""" # EEG/ECG Radio button self.mode_control = RadioButtonGroup(labels=MODE_LIST, active=0) self.mode_control.on_click(self._change_mode) self.t_range = Select(title="Time window", value="10 s", options=list(TIME_RANGE_MENU.keys()), width=210) self.t_range.on_change('value', self._change_t_range) self.y_scale = Select(title="Y-axis Scale", value="1 mV", options=list(SCALE_MENU.keys()), width=210) self.y_scale.on_change('value', self._change_scale) # Create device info tables columns = [TableColumn(field='heart_rate', title="Heart Rate (bpm)")] self.heart_rate = DataTable(source=self.heart_rate_source, index_position=None, sortable=False, reorderable=False, columns=columns, width=200, height=50) columns = [TableColumn(field='firmware_version', title="Firmware Version")] self.firmware = DataTable(source=self.firmware_source, index_position=None, sortable=False, reorderable=False, columns=columns, width=200, height=50) columns = [TableColumn(field='battery', title="Battery (%)")] self.battery = DataTable(source=self.battery_source, index_position=None, sortable=False, reorderable=False, columns=columns, width=200, height=50) columns = [TableColumn(field='temperature', title="Temperature (C)")] self.temperature = DataTable(source=self.temperature_source, index_position=None, sortable=False, reorderable=False, columns=columns, width=200, height=50) columns = [TableColumn(field='light', title="Light (Lux)")] self.light = DataTable(source=self.light_source, index_position=None, sortable=False, reorderable=False, columns=columns, width=200, height=50) # Add widgets to the doc m_widgetbox = widgetbox([self.mode_control, self.y_scale, self.t_range, self.heart_rate, self.battery, self.temperature, self.light, self.firmware], width=220) return m_widgetbox
def setupControls(self): boardModeButtons = RadioButtonGroup(labels=self.boardModes, active=0, width=400, button_type="primary") boardModeButtons.on_change("active", self.boardModeCallback) self.brightnessSlider = Slider(title="Brightness", show_value=False, height=self.figureSize, value=.5, start=0, end=1, step=.1, orientation="vertical") self.brightnessSlider.on_change("value", self.brightnessCallback) #create an empty row to store the active controls in activeControlsBox = column(name="activeControls") #setup the image handler controls to control the board cIS.iconFileSource.on_change('data', self.iconFileCallback) self.controls = column(boardModeButtons, activeControlsBox)
def view_setup(self): self.text5 = Div(text="Ticker downloader:", width=150) self.tickerdownloader = TextInput(value='', width=80) self.tickerdownloadbutton = Button(label='Press to download', button_type='default', disabled=False, width=50) self.tickerdownloadbutton.on_click(self.tickerdownloadbutton_handler) self.exchangebutton = RadioButtonGroup(labels=["NYSE", "NASDAQ"], active=0, width=140) self.exchangebutton.on_change("active", self.exchange) self.widgets = column( column(self.text5, self.tickerdownloader, self.tickerdownloadbutton, self.exchangebutton)) main_row = row(self.widgets) layout = column(main_row) curdoc().add_root(layout) curdoc().title = "Stocks"
update_plot(f, N, t_start, t_end) # initialize data source source_fourier = ColumnDataSource(data=dict(t=[], x_fourier=[])) source_orig = ColumnDataSource(data=dict(t=[], x_orig=[])) source_interval_patch = ColumnDataSource(data=dict(x_patch=[], y_patch=[])) source_interval_bound = ColumnDataSource(data=dict(x_min=[], x_max=[], y_minmax=[])) source_coeff = ColumnDataSource(data=dict(a=[], b=[])) source_f = ColumnDataSource(data=dict(f=[None])) source_periodicity = ColumnDataSource(data=dict(t_start=[None], t_end=[None])) source_view = ColumnDataSource(data=dict(x_start=[None], x_end=[None], y_start=[None], y_end=[None])) # initialize controls # buttons for choosing a sample function sample_function_type = RadioButtonGroup(labels=fs.function_names, active=fs.function_init) # here one can choose arbitrary input function default_function_input = TextInput(value=fs.function_input_init) default_function_period_start = TextInput(title='period start', value=fs.timeinterval_start_init) default_function_period_end = TextInput(title='period end', value=fs.timeinterval_end_init) # slider controlling degree of the fourier series degree = Slider(title="degree", name='degree', value=fs.degree_init, start=fs.degree_min, end=fs.degree_max, step=fs.degree_step) # initialize callback behaviour degree.on_change('value', degree_change) default_function_input.on_change('value', type_input_change) # todo write default functions for any callback, like above default_function_period_start.on_change('value', type_input_change)
p2 = figure(width = 600, height = 400, title = 'Area difference of Nearest Neighbors', x_axis_label = 'Formation time, s') p2.segment('x', 'sdplus', 'x', 'sdminus', source = s2, line_width = 2) p2.circle('x', 'y', color = 'color', source = s2, size = 12, alpha = 0.65) p3 = figure(width = 600, height = 400, title = 'Plot of Area vs. Area', x_axis_label = 'Area (um^2)', y_axis_label = 'Area (um^2)') p3.segment('x', 'ysdplus', 'x', 'ysdminus', source = s3, line_width = 2) p3.segment('xsdplus', 'y', 'xsdminus', 'y', source = s3, line_width = 2) p3.circle('x', 'y', color = 'color', source = s3, size = 12, alpha = 0.65) # Set up widgets kneighb = Slider(title = 'Number of nearest neighbors to average', value = 1, start = 1, end = (k - 1), step = 1) radio_button_group1 = RadioButtonGroup(labels=["NN Distance", "NN Index"], active = 0) radio_button_group2 = RadioButtonGroup(labels=["Average", "NN Difference", "NN Difference Index"], active=0) menu = [('Area', 'Area'), ('Coherency', 'Coherency'), ('Orientaiton', 'Orientation')] dropdown = Dropdown(label = 'Lower Right Parameter', menu = menu, value = 'Area') menu2 = [('Area', 'Area'), ('Coherency', 'Coherency'), ('Orientaiton', 'Orientation'), ('Distance', 'Distance')] x3drop = Dropdown(label = 'Lower Left X-axis', menu = menu2, value = 'Area') y3drop = Dropdown(label = 'Lower Left Y-axis', menu = menu2, value = 'Area') pTXT = Paragraph(text = """Welcome to the interactive Nearest Neighbor data explorer. The first toggle controls the top right plot, selecting average NN distance in microns, or NN Index (normalized by the number of domains). The next menus control the lower two plots: select which parameter to be plotted with the dropdown menus, and use the toggle to pick average value, average NN difference, or NN difference index. Green points are constant flow series, Pink are constant volume series. Error bars are 1/4 standard deviation.""") w = widgetbox(pTXT, radio_button_group1, dropdown, x3drop, y3drop, radio_button_group2)
widgets.append(x_field) y_field = Select( title = 'Y-Axis Value', options=sorted([ (key, val) for (key, val) in cols.items() ], key = lambda x:x[1]), value = 'best_mt_score' ) widgets.append(y_field) hide_null = Toggle( active=True, label="Hide 0 results with null X or Y axis values" ) widgets.append(hide_null) presets = RadioButtonGroup( labels=["MT vs WT Epitope Affinity", "Tumor Clonality and Expression"], active=0) def available(x): for entry in entries: if x in entry and entry[x] is not None: return True return False if not available('corresponding_wt_score') or not available('best_mt_score'): presets.labels.remove('MT vs WT Epitope Affinity') if not available('tumor_dna_vaf') or not available('tumor_rna_vaf'): presets.labels.remove('Tumor Clonality and Expression') widgets.append(presets) #Set up the data dictionary (a transposed version of entries) data_dict = {
dropdown_disabled = Dropdown(label="Dropdown button (disabled)", button_type="warning", disabled=True, menu=menu) dropdown_disabled.js_on_click(CustomJS(code="console.log('dropdown_disabled: ' + this.value, this.toString())")) #dropdown_split = Dropdown(label="Split button", button_type="danger", menu=menu, default_value="default") #dropdown_split.js_on_click(CustomJS(code="console.log('dropdown_split: ' + this.value, this.toString())")) checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1]) checkbox_group.js_on_click(CustomJS(code="console.log('checkbox_group: ' + this.active, this.toString())")) radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0) radio_group.js_on_click(CustomJS(code="console.log('radio_group: ' + this.active, this.toString())")) checkbox_button_group = CheckboxButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1]) checkbox_button_group.js_on_click(CustomJS(code="console.log('checkbox_button_group: ' + this.active, this.toString())")) radio_button_group = RadioButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=0) radio_button_group.js_on_click(CustomJS(code="console.log('radio_button_group: ' + this.active, this.toString())")) widget_box = WidgetBox(children=[ button, button_disabled, toggle_inactive, toggle_active, dropdown, dropdown_disabled, #dropdown_split, checkbox_group, radio_group, checkbox_button_group, radio_button_group, ]) doc = Document() doc.add_root(widget_box) if __name__ == "__main__": doc.validate()
#dropdown_split.on_click(lambda value: print('dropdown_split: %s' % value)) #dropdown_split.js_on_click(CustomJS(code="console.log('dropdown_split: ' + this.value, this.toString())")) checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1]) checkbox_group.on_click(lambda value: print('checkbox_group: %s' % value)) checkbox_group.js_on_click(CustomJS(code="console.log('checkbox_group: ' + this.active, this.toString())")) radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0) radio_group.on_click(lambda value: print('radio_group: %s' % value)) radio_group.js_on_click(CustomJS(code="console.log('radio_group: ' + this.active, this.toString())")) checkbox_button_group = CheckboxButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1]) checkbox_button_group.on_click(lambda value: print('checkbox_button_group: %s' % value)) checkbox_button_group.js_on_click(CustomJS(code="console.log('checkbox_button_group: ' + this.active, this.toString())")) radio_button_group = RadioButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=0) radio_button_group.on_click(lambda value: print('radio_button_group: %s' % value)) radio_button_group.js_on_click(CustomJS(code="console.log('radio_button_group: ' + this.active, this.toString())")) widgetBox = WidgetBox(children=[ button, button_disabled, toggle_inactive, toggle_active, dropdown, dropdown_disabled, #dropdown_split, checkbox_group, radio_group, checkbox_button_group, radio_button_group, ]) document = curdoc() document.add_root(widgetBox) if __name__ == "__main__":
X = np.copy(X_init) hist, edges = np.histogram(X, density=True, bins=50) p1 = figure(x_range=[-10, 10], y_range=[-0.7, 0.7]) p1.add_tools(ResizeTool()) r1 = p1.line(x, y, color="navy") h1 = p1.quad(top=hist, bottom=0, left=edges[:-1], right=edges[1:], fill_color="#036564", line_color="#033649", alpha=0.5) p2 = figure() p2.add_tools(ResizeTool()) h2 = p2.quad(top=hist, bottom=0, left=edges[:-1], right=edges[1:], fill_color="#036564", line_color="#033649", alpha=0.5) slider = Slider(start=1, end=10, value=1, step=.1, title="Speed") button_group = RadioButtonGroup(labels=["Play", "Pause"], active=1) button = Button(label="Reset", button_type="warning") it = PreText(text="Iteration 1") wb = widgetbox(slider, button_group, button, it) session = push_session(curdoc()) def redraw(): hist, edges = np.histogram(X, density=True, bins=50) h1.data_source.data["top"] = hist h1.data_source.data["left"] = edges[:-1] h1.data_source.data["right"] = edges[1:] hist, edges = np.histogram(math.sqrt(step)*X, density=True, bins=50) h2.data_source.data["top"] = hist
from bokeh.plotting import figure x=[3,4,6,12,10,1,5,6,3,8] y=[7,1,3,4,1,6,10,4,10,3] label=['Red', 'Orange', 'Red', 'Orange','Red', 'Orange','Red', 'Orange','Red', 'Orange',] df=pd.DataFrame({'x':x,'y':y,'label':label}) source = ColumnDataSource(data=dict(x=df.x, y=df.y,label=df.label)) plot_figure = figure(title='Radio Button Group',plot_height=450, plot_width=600, tools="save,reset", toolbar_location="below") plot_figure.scatter('x', 'y',color='label', source=source, size=10) radio_button_group = RadioButtonGroup(labels=["Red", "Orange"]) def radiogroup_click(attr,old,new): active_radio=radio_button_group.active ##Getting radio button value # filter the dataframe with value in radio-button if active_radio==0: selected_df = df[df['label'] == 'Red'] elif active_radio==1: selected_df = df[df['label'] == "Orange"] source.data=dict(x=selected_df.x, y=selected_df.y,label=selected_df.label) radio_button_group.on_change('active',radiogroup_click)
dropdown = Dropdown(label="Dropdown button", type="warning", menu=menu) dropdown.on_click(dropdown_handler) menu = [("Item 1", "foo"), ("Item 2", "bar"), None, ("Item 3", "baz")] split = Dropdown(label="Split button", type="danger", menu=menu, default_action="baz") split.on_click(split_handler) checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1]) checkbox_group.on_click(checkbox_group_handler) radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0) radio_group.on_click(radio_group_handler) checkbox_button_group = CheckboxButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1]) checkbox_button_group.on_click(checkbox_button_group_handler) radio_button_group = RadioButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=0) radio_button_group.on_click(radio_button_group_handler) vbox = VBox(children=[button, toggle, dropdown, split, checkbox_group, radio_group, checkbox_button_group, radio_button_group]) document.add(vbox) session.store_document(document) if __name__ == "__main__": link = session.object_link(document.context) print("Please visit %s to see the plots" % link) view(link) print("\npress ctrl-C to exit") session.poll_document(document)
p_title.grid.grid_line_color = None p_title.outline_line_color = None p_title.axis.visible = None # put Cylance Logo in # p_logo = figure(toolbar_location=None, tools = "lasso_select", x_range=(0,1), y_range=(0,1), plot_width=520, plot_height=200) # img = mpimg.imread("cylance_logo.png") # p_logo.image_url(url=["cylance_logo.png"], x=0, y=0) # p_logo.background_fill_color = "black" # p_logo.border_fill_color = "black" # p_logo.grid.grid_line_color = "black" # p_logo.outline_line_color = "black" # radio button group for uploading file radio_group = RadioButtonGroup(labels=["NO-SPLIT", "SPLIT", "START"], button_type="success") radio_group.width = 500 radio_group.on_click(_fit_util) # text for console output text_input = TextInput(value="", title="CONSOLE") text_input.width = 500 cluster_stats = Div( render_as_text=False, text=generate_display_string("", name="Cluster Statistics", height=100) ) cluster_stats.width = 500 cluster_stats.height = 100 cluster_commonality = Div(
''' ran change from original ''' def open_local_file(attr,old,new): labels.text = ["chosen file is : " + tkFileDialog.askopenfilename()] print labels.text def open_local_file_long(attr,old,new): import wx import os app = wx.PySimpleApp() wildcard = "Python source (*.py)|*.py|" \ "Compiled Python (*.pyc)|*.pyc|" \ "All files (*.*)|*.*" dialog = wx.FileDialog(None, "Choose a file", os.getcwd(), "", wildcard, wx.OPEN) if dialog.ShowModal() == wx.ID_OK: print dialog.GetPath() dialog.Destroy() #create select widget options=["average_grades","exam_grades","student_names"] radio_button_group=RadioButtonGroup(labels=options) # radio_button_group.on_change("active",update_labels) radio_button_group.on_change("active",open_local_file) #create layout and add to curdoc lay_out=layout([[radio_button_group]]) curdoc().add_root(f) curdoc().add_root(lay_out)
snr_plot.yaxis.axis_label='F_p/F_s (x10^9)' snr_plot.xaxis.axis_label='Wavelength [micron]' snr_plot.line('lam','cratio',source=planet,line_width=2.0, color="green", alpha=0.7) snr_plot.circle('lam', 'spec', source=planet, fill_color='red', line_color='black', size=8) snr_plot.segment('lam', 'downerr', 'lam', 'uperr', source=planet, line_width=1, line_color='grey', line_alpha=0.5) def change_filename(attrname, old, new): format_button_group.active = None instruction0 = Div(text="""Choose a file rootname here (no special characters):""", width=300, height=15) text_input = TextInput(value="filename", title=" ", width=100) instruction1 = Div(text="""Then choose a format here:""", width=300, height=15) format_button_group = RadioButtonGroup(labels=["txt", "fits"]) instruction2 = Div(text="""Your file will be linked here:""", width=300, height=15) link_box = Div(text=""" """, width=300, height=15) def i_clicked_a_button(new): filename=text_input.value + {0:'.txt', 1:'.fits'}[format_button_group.active] print "Your format is ", format_button_group.active, {0:'txt', 1:'fits'}[format_button_group.active] print "Your filename is: ", filename fileformat={0:'txt', 1:'fits'}[format_button_group.active] link_box.text = """Working""" t = Table(planet.data) t = t['lam', 'spec','cratio','uperr','downerr'] if (format_button_group.active == 1): t.write(filename, overwrite=True)