def make_figure(): #set up plot plot = figure(plot_height=400, plot_width=400, title="Sine Wave", tools=TOOLS, x_range=[0,4*np.pi], y_range=[-5,5]) plot.line('x','y', source=source, line_width=3) plot.scatter('x','y', source=source,size=5) #call back CustomJS callback = CustomJS(args=dict(source=source), code=""" var data = source.get('data') var f = cb_obj.get('value') x = data['x'] y = data['y'] for (i = 0; i < x.length; i++) { y[i] = f*Math.sin(x[i]) } source.trigger('change'); """) #add slider amplitude = Slider(title="Amplitude", value=amp, start=0, end=5, callback=callback) #plot layout = VBoxForm(amplitude,plot) show(layout) return layout #need to return the layout
def buildVendorsTab(): defaultGfxVendors = [ gfxVendors.index('NVIDIA Corporation'), gfxVendors.index('Advanced Micro Devices, Inc. [AMD/ATI]'), gfxVendors.index('Intel Corporation') ] gfxVendorCheckbox = CheckboxGroup(labels=gfxVendors, active=defaultGfxVendors) source_release = ColumnDataSource(data=dict(x=[], y=[], height=[])) source_beta = ColumnDataSource(data=dict(x=[], y=[], height=[])) fig = Figure(title="GFX Vendors", x_range=[], y_range=[0, 0], plot_width=1000, plot_height=650) hover = HoverTool(tooltips=[ ('Users', '@height %') ]) fig.add_tools(hover) fig.rect(x='x', y='y', height='height', source=source_release, width=0.4, color='orange', legend='Release') fig.rect(x='x', y='y', height='height', source=source_beta, width=0.4, color='blue', legend='Beta') fig.xaxis.major_label_orientation = np.pi / 3 def update(selected): vendors = [gfxVendors[i] for i in range(len(gfxVendors)) if i in selected] releaseUsers = 100 * getUsersForVendors('release', vendors) / gfxTotalReleaseUsers betaUsers = 100 * getUsersForVendors('beta', vendors) / gfxTotalBetaUsers fig.x_range.factors = vendors fig.y_range.end = max([releaseUsers.max(), betaUsers.max()]) source_release.data = dict( x=[c + ':0.3' for c in vendors], y=releaseUsers / 2, height=releaseUsers, ) source_beta.data = dict( x=[c + ':0.7' for c in vendors], y=betaUsers / 2, height=betaUsers, ) gfxVendorCheckbox.on_click(update) update(gfxVendorCheckbox.active) vendorComparison = HBox(HBox(VBoxForm(*[gfxVendorCheckbox]), width=300), fig, width=1100) return Panel(child=vendorComparison, title="GFX Vendor Comparison")
def dataurl_change(attr, old, new): if new != "DEMO": try: source_url.data = requests.get(new).json() inputs = VBoxForm(text, threshold, dataurl) curdoc().remove_root(plot) curdoc().add_root(HBox(inputs, plot, width=800)) except: logging.warn("unable to fetch {}".format(new)) update_data()
def buildOSesTab(): osesCheckbox = CheckboxGroup(labels=oses, active=[i for i in range(len(oses))]) source_release = ColumnDataSource(data=dict(x=[], y=[], height=[])) source_beta = ColumnDataSource(data=dict(x=[], y=[], height=[])) fig = Figure(title='OS', x_range=[], y_range=[0, 0], plot_width=1000, plot_height=650) hover = HoverTool(tooltips=[ ('Users', '@height %') ]) fig.add_tools(hover) fig.rect(x='x', y='y', height='height', source=source_release, width=0.4, color='orange', legend='Release') fig.rect(x='x', y='y', height='height', source=source_beta, width=0.4, color='blue', legend='Beta') fig.xaxis.major_label_orientation = np.pi / 3 def update(selected): cur_oses = [oses[i] for i in range(len(oses)) if i in selected] releaseUsers = 100 * getUsersForOses('release', cur_oses) / osTotalReleaseUsers betaUsers = 100 * getUsersForOses('beta', cur_oses) / osTotalBetaUsers fig.x_range.factors = cur_oses fig.y_range.end = max([releaseUsers.max(), betaUsers.max()]) source_release.data = dict( x=[c + ':0.3' for c in cur_oses], y=releaseUsers / 2, height=releaseUsers, ) source_beta.data = dict( x=[c + ':0.7' for c in cur_oses], y=betaUsers / 2, height=betaUsers, ) osesCheckbox.on_click(update) update(osesCheckbox.active) osesComparison = HBox(HBox(VBoxForm(*[osesCheckbox]), width=300), fig, width=1100) return Panel(child=osesComparison, title="OS Comparison")
def integration_with_sliders(rsys, tend, c0, parameters, fig_kwargs=None, unit_registry=None, output_conc_unit=None, output_time_unit=None, slider_kwargs=None, x_axis_type="linear", y_axis_type="linear", integrate_kwargs=None, odesys_extra=None, get_odesys_kw=None): """ Parameters ---------- odesys_extra : tuple of :class:`pyodesys.ODESys` & dict From :func:`chempy.kinetics.ode.get_odesys`. get_odesys_kw : dict If odesys_extra is ``None`` the user may pass this for :func:`chempy.kinetics.ode.get_odesys`. """ import numpy as np from bokeh.plotting import Figure from bokeh.models import ColumnDataSource, HBox, VBoxForm from bokeh.models.widgets import Slider if slider_kwargs is None: slider_kwargs = {} if get_odesys_kw is None: get_odesys_kw = {} if odesys_extra is None: odesys, extra = get_odesys(rsys, **get_odesys_kw) else: odesys, extra = odesys_extra state_keys, rarg_keys, p_units = [ extra[k] for k in ('param_keys', 'unique', 'p_units') ] if output_conc_unit is None: output_conc_unit = 1 if output_time_unit is None: output_conc_unit = 1 param_keys = list(chain(state_keys, rarg_keys)) if x_axis_type == 'linear': tout = linspace(tend * 0, tend) elif x_axis_type == 'log': tout = logspace_from_lin(tend * 1e-9, tend) else: raise NotImplementedError("Unknown x_axis_type: %s" % x_axis_type) tout, Cout, info = odesys.integrate(tout, c0, parameters, **(integrate_kwargs or {})) sources = [ ColumnDataSource( data={ 'tout': to_unitless(tout, output_time_unit), k: to_unitless(Cout[:, idx], output_conc_unit) }) for idx, k in enumerate(rsys.substances) ] if fig_kwargs is None: Cmax = np.max(Cout) x_range = list(to_unitless([tend * 0, tend], output_time_unit)) y_range = list(to_unitless([Cmax * 0, Cmax * 1.1], output_conc_unit)) fig_kwargs = dict(plot_height=400, plot_width=400, title="C vs t", tools="crosshair,pan,reset,resize,save,wheel_zoom", x_range=x_range, y_range=y_range, x_axis_type=x_axis_type, y_axis_type=y_axis_type) plot = Figure(**fig_kwargs) colors = 'red green blue black cyan magenta'.split() for idx, k in enumerate(rsys.substances): plot.line('tout', k, source=sources[idx], line_width=3, line_alpha=0.6, color=colors[idx % len(colors)]) def _C(k): return to_unitless(c0[k], output_conc_unit) if p_units is None: p_units = [None] * len(param_keys) p_ul = [ to_unitless(parameters[k], _u) for k, _u in zip(param_keys, p_units) ] c0_widgets = OrderedDict([ (k, Slider(title=k if output_conc_unit is 1 else k + ' / ' + output_conc_unit.dimensionality.unicode, value=_C(k), **slider_kwargs.get( k, dict(start=_C(k) / 2, end=_C(k) * 2, step=_C(k) / 10)))) for k in rsys.substances ]) def _dict_to_unitless(d, u): return {k: to_unitless(v, u) for k, v in d.items()} param_widgets = OrderedDict([ (k, Slider(title=k if u is None else k + ' / ' + u.dimensionality.unicode, value=v, **_dict_to_unitless( slider_kwargs.get( k, dict(start=v / 10, end=v * 10, step=v / 10)), u))) for k, v, u in zip(param_keys, p_ul, p_units) ]) all_widgets = list(chain(param_widgets.values(), c0_widgets.values())) def update_data(attrname, old, new): _c0 = defaultdict(lambda: 0 * output_conc_unit) for k, w in c0_widgets.items(): _c0[k] = w.value * output_conc_unit _params = {} for (k, w), u in zip(param_widgets.items(), p_units): _params[k] = w.value if u is None else w.value * u _tout, _Cout, _info = odesys.integrate(tout, _c0, _params) for idx, k in enumerate(rsys.substances): sources[idx].data = { 'tout': to_unitless(_tout, output_time_unit), k: to_unitless(_Cout[:, idx], output_conc_unit) } for w in all_widgets: w.on_change('value', update_data) inputs = VBoxForm(children=all_widgets) return HBox(children=[inputs, plot], width=800)
# Set up callbacks def update_title(attrname, old, new): plot.title = attrname text.on_change('value', update_title) def update_data(attrname, old, new): # Get the current slider values a = amplitude.value b = offset.value w = phase.value k = freq.value # Generate the new curve x = np.linspace(0, 4 * np.pi, N) y = a * np.sin(k * x + w) + b source.data = dict(x=x, y=y) for w in [offset, amplitude, phase, freq]: w.on_change('value', update_data) # Set up layouts and add to document inputs = VBoxForm(children=[text, offset, amplitude, phase, freq]) curdoc().add_root(HBox(children=[inputs, plot], width=800))
} source = ColumnDataSource(data=dict(x=[],y=[],height=[])) cities=TextInput(title='location name') companies=TextInput(title='company name') industries=TextInput(title='industry name') x_axis=Select(title='X axis',options=sorted(axis_map.keys()),value='Current Industry') plot = figure(plot_height=600, plot_width=800, title="", toolbar_location=None, tools=[hover],x_range=industry[:10],y_range=[0,2000]) plot.rect(x='x',y='y',width=.8,height='height',source=source) plot.xaxis.major_label_orientation = np.pi/3 controls=[x_axis,cities,companies,industries] inputs=HBox(VBoxForm(*controls)) def select_types(): city_val=cities.value.strip() company_val=companies.value.strip() industry_val=industries.value.strip() selected=data_all.copy() if(city_val!=""): selected=selected[selected['location'].str.contains(city_val)==True] if(company_val!=""): selected=selected[selected['company'].str.contains(company_val)==True] if(industry_val!=""): selected=selected[selected['industry'].str.contains(industry_val)==True] return selected
def update_data(attrname, old, new): # Get the current slider values emax = eps_max.value E = modulus.value sy = yield_stress.value n = hard_exp.value # Generate the new curve eps = np.linspace(0, emax, N) sigma = Hollomon(eps, E=E, sy=sy, n=n) source.data = dict(x=eps, y=sigma) plot.x_range.end = eps.max() plot.y_range.end = sigma.max() for w in [eps_max, modulus, yield_stress, hard_exp]: w.on_change('value', update_data) # Set up layouts and add to document inputs = VBoxForm(children=[text, eps_max, modulus, yield_stress, hard_exp]) curdoc().add_root(HBox(children=[inputs, plot], width=800)) from bokeh.embed import file_html html = file_html(plot, "CDN", "my plot")
df_outliers_removed = outliers(df_subset, np.float(threshold_value)) selection_dict = { 'x': df_outliers_removed[x_feature_value + '_x'], 'y': df_outliers_removed[y_feature_value + '_y'] } return selection_dict # Update plot def update(attr, old, new): plot_dict = select_features() source.data = plot_dict # Define controls list # While server is running, update the values input_values = [x_feature, y_feature, threshold] for value in input_values: value.on_change('value', update) inputs = VBox(VBoxForm(*input_values), width=300) update(None, None, None) # initial load of the data curdoc().add_root(HBox(inputs, plot, width=1100))
for n, param in enumerate(params): # get all parameter values: exec(param + " = " + 'param{0}.value'.format(n)) # Generate the new curve: exec(new_plot_info[0]) # execute y = f(x, params) source.data = dict(x=x, y=y) for w in Slider_instances: w.on_change('value', update_data) # Set up layouts and add to document inputs = VBoxForm(children=Slider_instances) layout = HBox(children=[inputs, plot], width=800) # embed app in html template old_file = "template.html" new_file = "embed_template.html" f1 = open(old_file, "r") f2 = open(new_file, "w+") for line in f1: if "IBPLOT" in line: f2.write(autoload_server(layout, session_id=session.id)) else: f2.write(line) f1.close()
session = push_session(document) file_name = "demo" IBPLOT_tags = find_tags(file_name + ".html") appLayoutList = [] for app_info in IBPLOT_tags: app = CreateApp(app_info) for w in app.sliderList: w.on_change('value', app.update_data) inputs = VBoxForm(children=app.sliderList) layout = HBox(children=[inputs, app.plot], width=800) document.add_root(layout) appLayoutList.append(layout) # embed app in html template old_file = file_name + ".html" new_file = "embed_" + file_name + ".html" f1 = open(old_file, "r") f2 = open(new_file, "w+") appNumber = 0 for line in f1: if 'IBPLOT' in line and line[0] != '#' and line[0] != '<': f2.write("<p>This app is created by the following tag: </p>")
# Generate the new curve x = [-cos(theta)] y = [-sin(theta)] angle_rad = acos(-x[0]) angle_degree = round(angle_rad * 180. / pi) plot.title = titlevalue + str(angle_degree) source.data = dict(x=x, y=y) for w in [mu, tau]: w.on_change('value', update_data) # Set up layouts and add to document inputs = VBoxForm(children=[mu, tau]) layout = HBox(children=[inputs, plot], width=800) # embed app in html template old_file = "sliding_ball.html" new_file = "sliding_ball_embed.html" f1 = open(old_file, "r") f2 = open(new_file, "w+") for line in f1: if "APP: [sliding_ball]" in line: f2.write(autoload_server(layout, session_id=session.id)) else: f2.write(line) f1.close()
select = Select(title="Repay options:", value="base", options=["base", "ASAP"]) def update_data(attrname, old, new): # Get the current slider values d['debt'] = debt_input.value d['repay'] = debt_repay.value d['cash'] = cash_start.value d['max_cash'] = cash_max.value d['pay'] = [s1_input.value, s2_input.value] d['expenses'] = expense_input.value if select.value == 'base': print("In logic ", select.value) d['pay_debt_faster'] = False else: d['pay_debt_faster'] = True update_graphic() interactive_list = [ debt_input, debt_repay, expense_input, cash_start, cash_max, s1_input, s2_input, select ] for w in interactive_list: w.on_change('value', update_data) # Set up layouts and add to document inputs = VBoxForm(children=interactive_list) curdoc().add_root(HBox(children=[inputs, plot], width=800))
def buildDevicesTab(): gfxVendorSelect = Select(title='Vendor', options=gfxVendors, value=gfxVendors[0]) gfxDeviceCheckbox = CheckboxGroup() source_release = ColumnDataSource(data=dict(x=[], y=[], height=[])) source_beta = ColumnDataSource(data=dict(x=[], y=[], height=[])) fig = Figure(title="GFX Devices", x_range=[], y_range=[0, 0], plot_width=1000, plot_height=650) hover = HoverTool(tooltips=[ ('Users', '@height %') ]) fig.add_tools(hover) fig.rect(x='x', y='y', height='height', source=source_release, width=0.4, color='orange', legend='Release') fig.rect(x='x', y='y', height='height', source=source_beta, width=0.4, color='blue', legend='Beta') fig.xaxis.major_label_orientation = np.pi / 3 def update_view(): vendor = gfxVendorSelect.value deviceNames = getDeviceNames('release', vendor, True) gfxDeviceCheckbox.labels = deviceNames devices = [deviceNames[i] for i in range(len(deviceNames)) if i in gfxDeviceCheckbox.active] releaseUsers = 100 * getUsersForDevices('release', vendor, devices) / gfxTotalReleaseUsers betaUsers = 100 * getUsersForDevices('beta', vendor, devices) / gfxTotalBetaUsers fig.x_range.factors = devices fig.y_range.end = max([releaseUsers.max(), betaUsers.max()]) source_release.data = dict( x=[c + ':0.3' for c in devices], y=releaseUsers / 2, height=releaseUsers, ) source_beta.data = dict( x=[c + ':0.7' for c in devices], y=betaUsers / 2, height=betaUsers, ) def update(attrname, old, new): gfxDeviceCheckbox.active = [i for i in range(5)] update_view() def click(selected): update_view() gfxVendorSelect.on_change('value', update) gfxDeviceCheckbox.on_click(click) update('value', '', gfxVendorSelect.value) deviceComparison = HBox(HBox(VBoxForm(*[gfxVendorSelect, gfxDeviceCheckbox]), width=300), fig, width=1100) return Panel(child=deviceComparison, title="GFX Device Comparison")
#inputs = VBoxForm(children=[text, offset, amplitude, phase, freq]) ticker_input = TextInput(value='SPFB.RTS') div_input = TextInput(value='1.') length_input = TextInput(value=str(start_candles)) format_input = TextInput(value='0') button = Button(label='Change') button.on_click(change_source) curdoc().clear() curdoc().add_root( HBox(children=[ button, ticker_input, div_input, length_input, format_input ], width=900)) for graph in graphs: inputs = VBoxForm(children=[graph.box, graph.scale, graph.text]) curdoc().add_root(HBox(children=[inputs, graph.plot], width=900)) curdoc().add_periodic_callback(reload_data, data_refresh_interval) except Exception as e: #button = Button(label='Error!') #curdoc().add_root(button) show_exception_info() text = PreText(text=traceback.format_exc()) #str(e) curdoc().clear() curdoc().add_root(text)
""" user_view_has_changed = my_bokeh_utils.check_user_view( source_view.data, plot_field) if user_view_has_changed: u_str = u_input.value v_str = v_input.value update_quiver_data(u_str, v_str) source_view.data = my_bokeh_utils.get_user_view(plot_field) # calculate data init_data() # lists all the controls in our app associated with the default_funs panel ww = 400 function_controls = VBoxForm( children=[u_input, v_input, VBox(width=ww, height=20)], width=ww) curve_controls = VBoxForm( children=[cx_input, cy_input, parameter_input, VBox(width=ww, height=10)], width=ww) # Panels for sample functions or default functions function_panel = Panel(child=function_controls, title='choose function') curve_panel = Panel(child=curve_controls, title='choose curve') # Add panels to tabs tabs = VBox(children=[Tabs(tabs=[function_panel, curve_panel])], width=ww) # refresh quiver field all 100ms curdoc().add_periodic_callback(refresh_quiver, 100) # make layout curdoc().add_root(
df = select_movies() x_name = axis_map[x_axis.value] y_name = axis_map[y_axis.value] p.xaxis.axis_label = x_axis.value p.yaxis.axis_label = y_axis.value p.title = "%d movies selected" % len(df) source.data = dict( x=df[x_name], y=df[y_name], color=df["color"], title=df["Title"], year=df["Year"], revenue=df["revenue"], alpha=df["alpha"], ) controls = [ reviews, boxoffice, genre, min_year, max_year, oscars, director, cast, x_axis, y_axis ] for control in controls: control.on_change('value', update) inputs = HBox(VBoxForm(*controls), width=300) update(None, None, None) # initial load of the data curdoc().add_root(HBox(inputs, p, width=1100))
text_props['text_font_size'] = "8pt" plot.text(x=0.825, y=0.15, text="TP", source=conf_source, **text_props) plot.text(x=0.925, y=0.15, text="FP", source=conf_source, **text_props) plot.text(x=0.825, y=0.05, text="FN", source=conf_source, **text_props) plot.text(x=0.925, y=0.05, text="TN", source=conf_source, **text_props) update_data() text.on_change('value', input_change) dataurl.on_change('value', dataurl_change) # There must be a better way: dataurl.callback = CustomJS(args=dict(auc=auc, sample_size=sample_size), code=""" // $("label[for='"+auc.id+"']").parentNode.remove(); document.getElementById(auc.id).parentNode.hidden = true; // $("label[for='"+sample_size.id+"']").parentNode.remove(); document.getElementById(sample_size.id).parentNode.hidden = true; """) for w in (threshold, text, auc, sample_size): w.on_change('value', input_change) vbox_items = [text, sample_size, threshold, auc] if HAS_REQUESTS: vbox_items.append(dataurl) inputs = VBoxForm(*vbox_items) curdoc().add_root(HBox(inputs, plot, width=800))
def get_data(f, name): shape = f[name].shape # Empty array data = np.empty(shape, dtype=np.float64) # read_direct to empty arrays f[name].read_direct(data) return data def select_data(): data_val = data_select.value with h5py.File('demo_data.hdf5', 'r') as f: return get_data(f, data_val) def update_data(attrname, old, new): # hardcoded length of 100 x = list(range(1, 101)) y = select_data() source.data = dict(x=x, y=y) data_select.on_change('value', update_data) inputs = VBoxForm(data_select, width=300) update_data(None, None, None) curdoc().add_root(HBox(inputs, p, width=1100))
if mu_str =='0': mu_str = '0.0' textFile_name = 'data/' + mu_str + '.txt' with open(textFile_name, 'r') as filename: n = 0 for line in filename: if n == N: theta = float(line.split()[1]) n += 1 filename.close() # Generate the new curve x = [-cos(theta)] y = [-sin(theta)] degree_rad = acos(-x[0]) degree_normal = round(degree_rad*180./pi) plot.title = text.value + str(degree_normal) source.data = dict(x=x, y=y) for w in [mu, tau]: w.on_change('value', update_data) # Set up layouts and add to document inputs = VBoxForm(children=[text, mu, tau]) curdoc().add_root(HBox(children=[inputs, plot], width=800))