Beispiel #1
0
 def add_countdown(self, vi_countdown):
     #- VI countdown
     assert vi_countdown > 0
     self.vi_countdown_callback = CustomJS(args=dict(vi_countdown=vi_countdown), code="""
         if ( (cb_obj.label).includes('Start') ) { // Callback doesn't do anything after countdown started
             var countDownDate = new Date().getTime() + (1000 * 60 * vi_countdown);
             var countDownLoop = setInterval(function(){
                 var now = new Date().getTime();
                 var distance = countDownDate - now;
                 if (distance<0) {
                     cb_obj.label = "Time's up !";
                     clearInterval(countDownLoop);
                 } else {
                     var days = Math.floor(distance / (1000 * 60 * 60 * 24));
                     var hours = Math.floor((distance % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
                     var minutes = Math.floor((distance % (1000 * 60 * 60)) / (1000 * 60));
                     var seconds = Math.floor((distance % (1000 * 60)) / 1000);
                     //var stuff = days + "d " + hours + "h " + minutes + "m " + seconds + "s ";
                     var stuff = minutes + "m " + seconds + "s ";
                     cb_obj.label = "Countdown: " + stuff;
                 }
             }, 1000);
         }
     """)
     self.vi_countdown_toggle = Toggle(label='Start countdown ('+str(vi_countdown)+' min)', active=False, button_type="success")
     self.vi_countdown_toggle.js_on_change('active', self.vi_countdown_callback)
Beispiel #2
0
    def create_index_sliders_toggle(self) -> Toggle:
        """
        Create the index sliders' visibility toggle button.

        Returns
        -------
        Toggle
            A Toggle type button instance to control index sliders' visibility.
        """

        sliders_toggle = Toggle(label="Plane Indices", active=False)
        sliders_toggle.on_click(self.toggle_index_sliders_visibility)
        return sliders_toggle
Beispiel #3
0
    def create_displayed_values_toggle(self):
        """
        Create the range sliders' visibility toggle button.

        Returns
        -------
        Toggle
            A Toggle type button instance to control range sliders' visibility.
        """

        displayed_values_toggle = Toggle(label="Displayed Values")
        displayed_values_toggle.on_click(self.toggle_range_sliders_visibility)
        return displayed_values_toggle
 def __init__(self,
              number: int,
              name: str,
              gui_name: str = "",
              selected: bool = False,
              incompatibilities: List[str] = []):
     self.number = number
     self.name = name
     self.gui_name = gui_name if gui_name else name
     self.selected = selected
     self.incompatibilities = incompatibilities
     self.incompatibility_count = 0
     self.button = Toggle(label=self.gui_name,
                          width=200,
                          button_type="primary")
     self.button.on_click(self.button_function)
Beispiel #5
0
def set_globals(parsed_result):
    global button_generate, buttons_toggle_x, dropdown_eval_method, slider_n_points, max_pars, source, old_active_list
    global result, x_eval_selectors, layout, x_eval_selectors_values, button_partial_dependence, y_value, button_color_map, colorbar, button_draw_confidence

    # Here we se the values of the global variables and create the layout
    result = parsed_result
    x_eval_selectors_values = copy.copy(result.x)
    max_pars = len(result.space.dimensions)

    # Layout
    button_generate = Button(label="Generate", button_type="success")
    button_generate.on_click(lambda: handle_button_generate(layout, result))
    buttons_toggle_x = CheckboxButtonGroup(
        labels=['x ' + str(s) for s in range(max_pars)], active=[])
    button_partial_dependence = Toggle(label="Use partial dependence",
                                       button_type="default")
    button_color_map = Toggle(label="Use same color map",
                              button_type="default")
    button_draw_confidence = Toggle(label="Draw upper confidence limit",
                                    button_type="default")
    dropdown_eval_method = Select(
        title="Evaluation method:",
        value='Result',
        options=['Result', 'Exp min', 'Exp min rand', 'Sliders'],
        width=200,
        height=40)
    slider_n_points = Slider(start=1,
                             end=20,
                             value=10,
                             step=1,
                             title="n-points",
                             width=200,
                             height=10)
    y_value = Div(text="""""", width=300, height=200)
    colorbar = Div(
    )  # We initiate colorbar as an empty div first and then change it to a plot in case we want to show it
    row_plots = row([])
    row_top = row(button_generate, buttons_toggle_x)
    col_right_side = column(button_partial_dependence, button_color_map,
                            button_draw_confidence, dropdown_eval_method,
                            slider_n_points, y_value, colorbar)
    col_left_side = column(row_top, row_plots)
    layout = row(col_left_side, col_right_side)
Beispiel #6
0
def init():
    output_notebook()
    display(Javascript(_init_js))
    but = '<img src="resources/show.png" width="34" height="25" style="display: inline" alt="Slideshow button" title="Enter/Exit RISE Slideshow">'
    txt = Div(text='<h2>You can now start the slideshow!</h3>' +
                   f'<h3 style="margin: 0.5em 0;">Just click the RISE slideshow button above - the one that looks like: {but}<br/>' +
                   '(or you can press alt+R on your keyboard instead if you prefer).</h3>')
    clearbutton = Button(label="Clear")
    clearbutton.js_on_click(CustomJS(code='primes_clear();'))
    cleartext = Paragraph(text='Clear all plots and outputs (e.g. before restarting slideshow).')
    increm = Toggle(label='Incremental', active=True)
    increm.js_on_click(CustomJS(code='primes_incremental(cb_obj.active)'))
    incremtext = Paragraph(text='Update timing plots incrementally (disable for static slide show).')
    repeats = Slider(start=1, end=10, value=3)
    repeats.js_on_change('value', CustomJS(code='primes_repeats(cb_obj.value)'))
    repeatstext = Paragraph(text='Repeats for timing measurements (higher is more accurate, but slower).')
    controls = layout([[clearbutton, cleartext],
                       [increm, incremtext],
                       [repeats, repeatstext]])
    show(column(txt, controls, sizing_mode='stretch_width'))
Beispiel #7
0
 def create_state_ctrls(self, btn_width=70, btn_container_width=90,
                         layout='row'):
     """
     Create state buttons: Run, Pause, Stop, Exit, etc.
     """
     btn_run = Button(label="Run", button_type="success")
     btn_run.on_click(self.on_run_handler)
     btn_pause = Toggle(label="Pause", button_type="primary")
     btn_pause.on_change('active', self.on_pause_handler)
     btn_stop = Button(label="Stop", button_type="default")
     btn_stop.on_click(self.on_stop_handler)
     btn_exit = Button(label="Exit", button_type="danger")
     btn_exit.on_click(self.on_exit_handler)
     tmp = []
     for btn in [btn_run, btn_pause, btn_stop, btn_exit]:
         btn.width = btn_width
         tmp.append(widgetbox(btn, width = btn_container_width))
     if layout == 'row':
         self.state_ctrls = row(tmp)
     else:
         self.state_ctrls = column(tmp)
class BasicOption:
    """ Basic option class. If you need to add further attributes to your
    options, create your class and inherit from this. """
    number: int
    name: str
    gui_name: str
    selected: bool
    incompatibilities: List[str]

    def __init__(self,
                 number: int,
                 name: str,
                 gui_name: str = "",
                 selected: bool = False,
                 incompatibilities: List[str] = []):
        self.number = number
        self.name = name
        self.gui_name = gui_name if gui_name else name
        self.selected = selected
        self.incompatibilities = incompatibilities
        self.incompatibility_count = 0
        self.button = Toggle(label=self.gui_name,
                             width=200,
                             button_type="primary")
        self.button.on_click(self.button_function)

    def button_function(self, state):
        """ Disables incompatible options. """
        if state:  # styling
            self.button.button_type = "success"
        else:
            self.button.button_type = "primary"
        for incomp_opt in self.incompatibilities:  # incompatibility logic
            if state:
                incomp_opt.incompatibility_count += 1
                incomp_opt.button.disabled = True
            else:
                incomp_opt.incompatibility_count -= 1
                if incomp_opt.incompatibility_count == 0:
                    incomp_opt.button.disabled = False
    def setupLyricTable(self):
        self.lyricTableHandler = dataTableGenerator(self.subtitleDict)
        # self.dtg.source.selected.on_change('indices', self.dataTableCallback)
        self.importFileButton = Button(label="Import file",
                                       button_type="success",
                                       width=self.buttonWidth)

        self.lyricModeButton = Toggle(label="Change to end lyric",
                                      button_type="success",
                                      width=self.buttonWidth)
        self.gui = column(self.lyricTableHandler.gui,
                          row(self.importFileButton, self.lyricModeButton),
                          width=self.toolWidth)
Beispiel #10
0
    def __init__(self, data):
        self.map_data = data
        p_wgs84 = pyproj.Proj(init='epsg:4326')
        p_web = pyproj.Proj(init='epsg:3857')

        self.map_data.shape_country['geometry'] = self.map_data.shape_country['geometry'].to_crs(epsg=3857)
        self.country_source = GeoJSONDataSource(
            geojson=self.map_data.shape_country.to_json()
        )
        self.priority_toggles = {}
        self.priority_groups = {}
        self.priority_groups_rect = {}

        self.priority_names = {
            10: 'High',
            20: 'Medium',
            30: 'Low'
        }

        self.map_width = 800
        self.map_height = 800

        tooltips_map = [
            ("Name", "@names"),
            ("POI", "@categories"),
        ]
        hover_map = HoverTool(tooltips=tooltips_map,
                              mode='mouse',
                              names=['marker']
                              )
        plot_options_map = dict(plot_height=self.map_height,
                                plot_width=self.map_width,
                                tools=["pan,wheel_zoom,reset,save", hover_map],
                                sizing_mode="fixed",
                                toolbar_location='above',
                                title='BiH'
                                )
        self.figure_map = figure(**plot_options_map)
        self.figure_map.xgrid.grid_line_color = None
        self.figure_map.ygrid.grid_line_color = None
        self.figure_map.xaxis.visible = False
        self.figure_map.yaxis.visible = False

        tile_provider = get_provider(Vendors.CARTODBPOSITRON)
        self.figure_map.add_tile(tile_provider)

        self.figure_map.multi_line('xs', 'ys',
                                   source=self.country_source,
                                   color='red',
                                   line_width=3
                                   )

        for shape in self.map_data.shape_municipalities:
            shape['geometry'] = shape['geometry'].to_crs(epsg=3857)
            source = GeoJSONDataSource(
                geojson=shape.to_json()
            )
            self.figure_map.patches('xs', 'ys',
                                    source=source,
                                    line_color='green',
                                    color='navy',
                                    alpha=0.1,
                                    line_width=2)

        for priority in map_data.priorities:
            df = self.map_data.data.loc[self.map_data.data['priority'] == priority]
            urls = ['BiH/static/symbols/' + str(icon) + '.png' for icon in df['icon'].tolist()]
            x = df['longitude'].tolist()
            y = df['latitude'].tolist()
            names = df['name'].tolist()

            categories = df['category'].tolist()

            x, y = pyproj.transform(p_wgs84, p_web, x, y)
            w = [32 for i in range(len(x))]
            h = [37 for i in range(len(x))]

            source_marker = ColumnDataSource(data={
                'urls': urls,
                'x': x,
                'y': y,
                'w': w,
                'h': h
            })
            self.priority_groups[priority] = self.figure_map.image_url(url='urls',
                                                                       x='x',
                                                                       y='y',
                                                                       w='w',
                                                                       h='h',
                                                                       h_units='screen',
                                                                       w_units='screen',
                                                                       anchor='center',
                                                                       source=source_marker)

            source_tooltip = ColumnDataSource(data={
                'x': x,
                'y': y,
                'names': names,
                'categories': categories,
                'w': w,
                'h': h
            })
            self.priority_groups_rect[priority] = self.figure_map.rect(
                x='x',
                y='y',
                width='w',
                height='h',
                fill_alpha=0,
                line_alpha=0,
                height_units='screen',
                width_units='screen',
                name='marker',
                source=source_tooltip)

        self.table_source = ColumnDataSource(data={
            'category': self.map_data.categories['category'],
            'icon': self.map_data.categories['icon'],
            'priority': self.map_data.categories['priority'],
            'priority_names': [self.priority_names[p] for p in self.map_data.categories['priority']]
        })
        columns = [TableColumn(field="icon",
                               title="Icon",
                               width=40,
                               formatter=HTMLTemplateFormatter(
                                   template='<img src="BiH/static/symbols/<%= value %>.png" height="37" width="32">'
                               )),
                   TableColumn(field="category", title="Category", width=180,
                               formatter=HTMLTemplateFormatter(
                                   template='<div style="position:relative;top:6px;font-size:12px;"><%= value %></div>'
                               )),
                   TableColumn(field="priority_names",
                               title="Priority",
                               width=80,
                               formatter=HTMLTemplateFormatter(
                                   template='<div style="position:relative;top:6px;font-size:12px;"><%= value %></div>'
                               )
                               )]

        data_view = CDSView(source=self.table_source, filters=[])

        self.table = DataTable(columns=columns,
                               source=self.table_source,
                               view=data_view,
                               sizing_mode='stretch_height',
                               index_position=None,
                               fit_columns=True,
                               width=300,
                               row_height=38,
                               selectable=False)

        for priority in self.map_data.priorities:
            toggle = Toggle(label=self.priority_names[priority], button_type='success', width=48)
            toggle.on_change("active", update_table)
            self.priority_toggles[priority] = toggle
Beispiel #11
0
from bokeh.io import output_file, show
from bokeh.layouts import widgetbox
from bokeh.models.widgets import Toggle

output_file("toggle.html")

toggle = Toggle(label="Foo", button_type="success")

show(widgetbox(toggle))
Beispiel #12
0
sample_size_input = Spinner(high=200,
                            low=2,
                            step=1,
                            value=10,
                            title="Sample Size for Simulations")

msmt_error_input = RangeSlider(
    start=0,
    end=100.,
    value=(10, 35),
    step=2,
    title="Measurement Uncertainty [%]",
)

toggle_button = Toggle(label="Simulate Measurement Error",
                       button_type="success")

ffa_info = Div(width=550,
               text="Mean of {} simulations for a sample size of {}.".format(
                   'x', 'y'))

error_info = Div(text="", style={'color': 'red'})

# Set up data table for summary statistics
datatable_columns = [
    TableColumn(field="parameter", title="Parameter"),
    TableColumn(field="value_all", title="All Data"),
    TableColumn(field="value_selection", title="Selected Data"),
]

data_table = DataTable(source=datatable_source,
Beispiel #13
0
Datei: viz.py Projekt: arzwa/wgd
def histogram_bokeh(ks_distributions, labels):
    """
    Run an interactive bokeh application.
    This requires a running bokeh server! Use ``bokeh serve &`` to start a bokeh
    server in the background.

    :param ks_distributions: a list of Ks distributions (pandas data frames)
    :param labels: a list of labels for the corresponding distributions
    :return: bokeh app
    """
    from bokeh.io import curdoc
    from bokeh.layouts import widgetbox, layout
    from bokeh.models.widgets import Select, TextInput, Slider, Div
    from bokeh.models.widgets import CheckboxGroup, Toggle
    from bokeh.plotting import figure, output_file, show
    from bokeh.client import push_session
    from pylab import cm
    from .utils import gaussian_kde
    from .modeling import reflect

    # helper functions
    def get_colors(cmap_choice='binary'):
        too_light = [
            'binary', 'hot', 'copper', 'pink', 'summer', 'bone', 'Pastel1',
            'Pastel2', 'gist_ncar', 'nipy_spectral', 'Greens'
        ]
        cmap = cm.get_cmap(cmap_choice, len(ks_distributions))
        if cmap_choice in too_light:
            cmap = cm.get_cmap(cmap_choice, len(ks_distributions) * 4)
        c = []
        for i in range(cmap.N):
            rgb = cmap(i)[:3]  # will return rgba, but we need only rgb
            c.append(matplotlib.colors.rgb2hex(rgb))
        if cmap_choice in too_light:
            if len(ks_distributions) > 1:
                c = c[2:-2]
            else:
                c = [c[-1]]
        return c

    def get_data(df, var, scale, r1, r2, outliers_included):
        df = filter_group_data(df,
                               min_ks=r1,
                               max_ks=r2,
                               weights_outliers_included=outliers_included)
        data = df[var].dropna()
        if scale == 'log10':
            data = np.log10(data)
        return data, df

    # get the distributions
    dists = [pd.read_csv(x, sep='\t') for x in ks_distributions]
    if labels:
        labels = labels.split(',')
    else:
        labels = ks_distributions

    # basics
    c = get_colors()
    variables = ['Ks', 'Ka', 'Omega']
    scales = ['Normal', 'log10']

    # set up widgets
    div = Div(text=BOKEH_APP_DIV, width=800)
    var = Select(title='Variable', value='Ks', options=variables)
    scale = Select(title='Scale', value='Normal', options=scales)
    r1 = TextInput(title="Minimum", value='0.1')
    r2 = TextInput(title="Maximum", value='5')
    bins = TextInput(title="Bins", value='50')
    bandwidth = TextInput(title="Bandwidth", value='0.1')
    line = Slider(title="Lines", start=0, end=1, value=0.3, step=0.1)
    density = CheckboxGroup(labels=["Histogram", "KDE"], active=[0])
    density_alpha = Slider(title="Density alpha value",
                           start=0,
                           end=1,
                           value=0.6,
                           step=0.1)
    hist_alpha = Slider(title="Histogram alpha value",
                        start=0,
                        end=1,
                        value=0.6,
                        step=0.1)
    color_choice = Select(options=[
        'binary', 'hsv', 'hot', 'magma', 'viridis', 'Greens', 'spring',
        'autumn', 'copper', 'cool', 'winter', 'pink', 'summer', 'bone', 'RdBu',
        'RdYlGn', 'coolwarm', 'inferno', 'Pastel1', 'Pastel2', 'tab10',
        'gnuplot', 'brg', 'gist_ncar', 'jet', 'rainbow', 'nipy_spectral',
        'ocean', 'cubehelix'
    ],
                          value='binary',
                          title='Color map')
    no_reweight = Toggle(label="Don't adapt weights when filtering",
                         active=False)

    # set up figure
    p1 = figure(
        plot_width=1000,
        plot_height=700,  # output_backend="svg",
        tools='pan,wheel_zoom,xwheel_zoom,ywheel_zoom,save')
    p1.xgrid.grid_line_color = None
    p1.ygrid.grid_line_color = None
    p1.border_fill_color = 'white'
    p1.outline_line_color = None
    p1.yaxis.axis_label = 'Duplications'
    p1.xaxis.axis_label = 'Ks'

    # draw initial plot
    hist_dict = {}
    density_dict = {}
    all_data = []

    # set up callbacks
    def update(selected=None):
        redraw_plots()

    def redraw_plots():
        print(density.active)
        c = get_colors(color_choice.value)
        p1.legend.items = []

        all_data = []
        for i in range(len(dists)):
            df = dists[i]
            data, df = get_data(df, var.value, scale.value, float(r1.value),
                                float(r2.value), no_reweight.active)
            all_data.append(data)

        edges = np.histogram(np.hstack(tuple(all_data)),
                             bins=int(bins.value))[1]

        for i in range(len(dists)):
            if density.active == [0]:
                hist = np.histogram(all_data[i], bins=int(bins.value))[0]
                p1.yaxis.axis_label = 'Duplications'
            else:
                hist = np.histogram(all_data[i],
                                    bins=int(bins.value),
                                    density=True)[0]
                p1.yaxis.axis_label = 'density'

            # First histograms
            if i in hist_dict:
                remove_plot(hist_dict, i)

            if 0 in density.active:
                hist_dict[i] = p1.quad(top=hist,
                                       bottom=0,
                                       left=edges[:-1],
                                       right=edges[1:],
                                       fill_color=c[i],
                                       line_color="black",
                                       fill_alpha=hist_alpha.value,
                                       line_alpha=line.value,
                                       legend=labels[i])

            # Then KDEs
            if i in density_dict:
                density_dict[i].data_source.data['x'] = []
                density_dict[i].data_source.data['y'] = []

            if 1 in density.active:
                X = reflect(all_data[i])
                kde = gaussian_kde(X, bw_method=float(bandwidth.value))
                x = np.linspace(
                    float(r1.value) + 0.000001, float(r2.value), 1000)
                if scale.value == 'log10':
                    x = np.log10(x)
                pdf = np.array(kde(x)) * 2

                # add boundaries such that it is a nice curve!
                pdf = np.hstack([0, pdf, 0])
                if scale.value == 'log10':
                    x = np.hstack([
                        np.log10(float(r1.value) + 0.00000099), x,
                        np.log10(float(r2.value) + 0.000001)
                    ])
                else:
                    x = np.hstack(
                        [float(r1.value), x,
                         float(r2.value) + 0.000001])

                density_dict[i] = p1.patch(x=x,
                                           y=pdf,
                                           fill_color=c[i],
                                           line_width=2,
                                           line_color="black",
                                           line_alpha=line.value,
                                           alpha=density_alpha.value,
                                           legend=labels[i])

            p1.legend.label_text_font_style = "italic"
            p1.legend.click_policy = "hide"
            p1.legend.inactive_fill_alpha = 0.6
            v = var.value
            if v == "Omega":
                v = "Ka/Ks"
            if scale.value == 'log10':
                v = 'log10(' + v + ')'
            p1.xaxis.axis_label = v

    def remove_plot(hist_dict, i):
        hist_dict[i].data_source.data["top"] = []
        hist_dict[i].data_source.data["left"] = []
        hist_dict[i].data_source.data["right"] = []

    def change_update(attrname, old, new):
        update()

    def feat_change(attrname, old, new):
        c = get_colors(color_choice.value)
        for i, d in density_dict.items():
            d.glyph.fill_color = c[i]
            d.glyph.line_color = "black"
            d.glyph.fill_alpha = density_alpha.value
            d.glyph.line_alpha = line.value
        for i, d in hist_dict.items():
            d.glyph.fill_color = c[i]
            d.glyph.line_color = "black"
            d.glyph.fill_alpha = hist_alpha.value
            d.glyph.line_alpha = line.value

    def bins_update(attrname, old, new):
        update()

    var.on_change('value', bins_update)
    bandwidth.on_change('value', bins_update)
    scale.on_change('value', bins_update)
    r1.on_change('value', bins_update)
    r2.on_change('value', bins_update)
    line.on_change('value', feat_change)
    bins.on_change('value', bins_update)
    color_choice.on_change('value', feat_change)
    density.on_change('active', bins_update)
    density_alpha.on_change('value', feat_change)
    hist_alpha.on_change('value', feat_change)
    no_reweight.on_change("active", bins_update)

    # set up layout
    widgets1 = widgetbox(var,
                         scale,
                         color_choice,
                         density,
                         line,
                         hist_alpha,
                         density_alpha,
                         r1,
                         r2,
                         bins,
                         bandwidth,
                         no_reweight,
                         sizing_mode='fixed')
    l = layout([
        [div],
        [widgets1, p1],
    ], sizing_mode='fixed')

    # initialize
    update()

    session = push_session(curdoc())
    curdoc().add_root(l)
    session.show(l)  # open the document in a browser
    session.loop_until_closed()  # run forever
    return  # show(p1)
Beispiel #14
0
def generate_km_plot(kms, models, color_dict):
    surv_plt1 = figure(title="Survival Analysis",
                       tools=['hover,box_zoom,wheel_zoom,save,reset'])
    hover = surv_plt1.select(dict(type=HoverTool))
    hover.tooltips = [("Model ", "@model"), ("Time ", "@timeline"),
                      ("survival fraction ", "@km_surv"),
                      ("upper 95% bound ", "@surv_upper"),
                      ("lower 95% bound ", "@surv_lower")]
    if len(kms) > 1:
        hover.mode = 'mouse'
    else:
        hover.mode = 'vline'

    km_colors = [
        '#1a1334', '#03c383', '#fbbf45', '#ed0345', '#26294a', '#aad962',
        '#01545a', '#ef6a32', '#017351', '#a12a5e', '#710162', '#110141'
    ]
    #km_colors = [str(color_dict[model_key]) if model_key in color_dict else 'grey' for model_key in models]

    n = 0
    surv_plt_objs1 = []
    surv_plt_objs2 = []
    for km in kms:
        model = models[n]
        time = km['time']
        surv = km['surv']
        surv_upper = km['surv_lower']
        surv_lower = km['surv_upper']
        band_x = np.append(time, time[::-1])
        band_y = np.append(surv_upper, surv_lower[::-1])
        source = ColumnDataSource(data=dict(timeline=[i for i in time],
                                            km_surv=[i for i in surv],
                                            model=[models[n] for i in time],
                                            surv_lower=[i for i in surv_lower],
                                            surv_upper=[i
                                                        for i in surv_upper]))
        tmp = surv_plt1.patch(band_x,
                              band_y,
                              color=km_colors[n],
                              fill_alpha=0.2)
        surv_plt_objs1.append(tmp)
        tmp = surv_plt1.line('timeline',
                             'km_surv',
                             line_width=2,
                             alpha=.8,
                             source=source,
                             legend=models[n],
                             color=km_colors[n])
        surv_plt_objs2.append(tmp)
        n += 1

    surv_plt1.xaxis.axis_label = 'Time (Years)'
    surv_plt1.yaxis.axis_label = 'Kaplan-Meier Estimation (survival fraction)'

    # grid styles
    surv_plt1.toolbar.logo = None
    surv_plt1.grid.grid_line_alpha = 0
    surv_plt1.ygrid.band_fill_color = None  #"grey"
    surv_plt1.ygrid.band_fill_alpha = 0.1
    surv_plt1.x_range.range_padding = 0
    surv_plt1.legend.location = "bottom_left"
    surv_plt1.plot_height = 700
    surv_plt1.plot_width = 790
    #surv_plt1.border_fill_color = "black"
    #surv_plt1.background_fill_color = "white"
    surv_plt1.min_border_left = 80
    surv_plt1.outline_line_width = 1
    surv_plt1.outline_line_alpha = 0.3
    surv_plt1.xaxis.minor_tick_line_color = None  #'N'
    surv_plt1.yaxis.minor_tick_line_color = None  #'#C1C1C1'
    #surv_plt1.xaxis.major_label_text_color = 'white'
    surv_plt1.y_range = Range1d(0.0, 1.02)

    code1 = '''\
    object1.visible = toggle.active
    object2.visible = toggle.active
    '''

    #Toggle possible attributes are:
    # active, button_type, callback, css_classes, disabled, height, icon, js_callbacks, label, name, sizing_mode, tags or width
    callbacks = []
    toggles = []
    for i in range(len(models)):
        callbacks.append(CustomJS.from_coffeescript(code=code1, args={}))
        km_color = km_colors[i].lstrip("#")
        style_class = ('bk-' + km_color, 'bk-' + km_color)
        toggles.append(
            Toggle(label=models[i],
                   button_type="success",
                   callback=callbacks[i],
                   css_classes=style_class))
        callbacks[i].args = {
            'toggle': toggles[i],
            'object1': surv_plt_objs1[i],
            'object2': surv_plt_objs2[i]
        }

    togs = [t for t in list(toggles)]
    controls = widgetbox(togs, width=190)
    layout = row(controls, surv_plt1)
    return layout
Beispiel #15
0
                d2['index'].push(             d1['index'][i]);
                d2['sx_value'].push(          d1['sx_value'][i]);
                d2['start_datetime_str'].push(d1['start_datetime_str'][i]);
                d2['end_datetime_str'].push(  d1['end_datetime_str'][i]);
                d2['start_datetime_dt'].push( d1['start_datetime_dt'][i]);
                d2['end_datetime_dt'].push(   d1['end_datetime_dt'][i]);
            }
    }
    source_sx_persistency.data = d2;
    console.log(d2);
    source_sx_persistency.change.emit();
    """))



toggle_sx = Toggle(label="Persistence", button_type="success", active=True)
toggle1 = Toggle(label="Word", button_type="success", active=True)
toggle1.js_link('active', r_wcrd_2, 'visible')

toggle2 = Toggle(label="Thumbnail", button_type="success", active=True)
toggle2.js_link('active', r_tcrd_2, 'visible')

slider_alpha_Value = Slider(start=0, end=1, value=1, step=.1, title="Alpha Value")
#slider.on_change('value', slider_onchange)
slider_alpha_Value.js_link('value', image_tcrd, 'global_alpha')

silder_draw_index = Slider(start=0, end=TSET_INTERVAL_NUM-1, value=FIRST_DRAW_INDEX, step=-1, title="Draw Index", direction="rtl", sizing_mode='stretch_width')
callback = CustomJS(
        args=dict(
            source_wcrd=source_wcrd, source_wcrd_view=source_wcrd_view,
            source_tcrd=source_tcrd, source_tcrd_view=source_tcrd_view,
Beispiel #16
0
    options=sorted([
        (key, val) for (key, val) in cols.items()
    ], key = lambda x:x[1]),
    value = 'corresponding_wt_score'
)
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'):
Beispiel #17
0

def checkbox_button_group_handler(active):
    print("checkbox_button_group_handler: %s" % active)


def radio_button_group_handler(active):
    print("radio_button_group_handler: %s" % active)


button = Button(label="Push button",
                icon=Icon(icon_name="check"),
                type="primary")
button.on_click(button_handler)

toggle = Toggle(label="Toggle button", type="success")
toggle.on_click(toggle_handler)

menu = [("Item 1", "item_1"), ("Item 2", "item_2"), None, ("Item 3", "item_3")]
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_value="baz")
split.on_click(split_handler)

checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"],
                               active=[0, 1])
def make_start_end_figure(doc):
    """
    Creates a Bokeh app for visualizations of start and end of hurricanes
    """
    df_spawn_end = pd.read_csv('files/df_start_end_bokeh.csv', index_col=0)

    year_min, year_max, lon_boundaries, lat_boundaries = get_boundaries(df_spawn_end)

    gulf_stream_lon1, gulf_stream_lon2, gulf_stream_lat1, gulf_stream_lat2 = get_gulf_stream()

    # credits of the map
    url = 'http://a.basemaps.cartocdn.com/rastertiles/voyager/{Z}/{X}/{Y}.png'
    attribution = "Tiles by Carto, under CC BY 3.0. Data by OSM, under ODbL"

    add_paragraph = additional_legend(loc='tracks')

    # -----------------------------------------------------
    # WIDGETS
    # -----------------------------------------------------

    # definition and configuration of the number selection
    options_number = ['-1'] + [str(x) for x in list(np.arange(1, 21))]
    select_number = Select(title='Number of hurricanes:', value='5', options=options_number)

    # definition and configuration of the zone selection
    options_zone = ['All', 'Mexico_Caribbean', 'Atlantic']
    select_zone = Select(title='Spawning Zone:', value='All', options=options_zone)

    # Definition of buttons for end points and distances
    toggle_month = Toggle(label="Show end points", button_type="success")
    toggle_dist_month = Toggle(label="Show distance traveled", button_type="success")

    # definition and configuration of the year and month sliders
    slider_year = RangeSlider(start=year_min, end=year_max,
                              value=(year_min, year_max), step=1, title="Years")

    slider_month = RangeSlider(start=1, end=12,
                               value=(1, 12), step=1, title="Months")

    # End points
    toggle_season = Toggle(label="Show end points", button_type="success")
    toggle_dist_season = Toggle(label="Show distance traveled", button_type="success")

    # definition and configuration of the number selection
    select_number_season = Select(title='Number of hurricanes:', value='5',
                                  options=options_number)

    # definition and configuration of the zone selection
    select_zone_season = Select(title='Spawning Zone:', value='All', options=options_zone)

    # definition and configuration of the year and sliders
    slider_year_season = RangeSlider(start=year_min, end=year_max,
                                     value=(year_min, year_max), step=1, title="Years")

    # definition and configuration of the season selection
    options_season = ['All', 'Winter', 'Spring', 'Summer', 'Autumn']
    select_season = Select(title='Season:', value='All', options=options_season)

    # -------------------------------------------------------
    # DATA SOURCE AND RANDOMIZATION
    # -------------------------------------------------------
    np.random.seed(42)
    n = 5

    select_list = list(np.random.choice(df_spawn_end.index, size=n, replace=False))
    filtr = df_spawn_end.index.map(lambda x: x in select_list)

    source = ColumnDataSource(data=df_spawn_end[filtr])

    # --------------------------------------------------------
    # FIRST TAB
    # --------------------------------------------------------

    # Initialization of the map
    p = figure(tools='pan, wheel_zoom', x_range=(lon_boundaries[0], lon_boundaries[1]),
               y_range=(lat_boundaries[0], lat_boundaries[1]),
               x_axis_type="mercator", y_axis_type="mercator")

    p.add_tile(WMTSTileSource(url=url, attribution=attribution))

    # Add data points
    # - Start
    # - End
    # - Start with size adjusted to the traveled distance
    c1 = p.circle(x='x_start', y='y_start', fill_color='green', size=8,
                  source=source, legend_label='Start points')

    c2 = p.circle(x='x_end', y='y_end', fill_color='orange', size=8,
                  source=source, legend_label='End points')

    d1 = p.circle(x='x_start', y='y_start', fill_color='green', radius='Distance_draw',
                  source=source)

    # Line between start and end points
    s1 = p.segment(x0='x_start', y0='y_start', x1='x_end', y1='y_end',
                   line_dash='dashed', source=source)

    # Initial configuration of WIDGETS  for FIRST TAB
    # - Don't show end points
    # - Don't show segments between start and end points
    # - Uniform size for starting points
    c2.visible, s1.visible, d1.visible = False, False, False

    # Configuration of the hovertool
    hover = HoverTool(tooltips=[("ID", "@ID"), ("Duration", "@Duration"),
                                ("Distance", "@Distance")],
                      renderers=[c1, c2, d1], formatters={'Duration': 'printf'})
    p.tools.append(hover)

    # Draw the Gulf Stream
    p.segment(x0=gulf_stream_lon1[:-1], y0=gulf_stream_lat1[:-1],
              x1=gulf_stream_lon1[1:], y1=gulf_stream_lat1[1:],
              legend_label='Gulf Stream', color='red', line_alpha=0.5, line_width=2)

    p.segment(x0=gulf_stream_lon2[:-1], y0=gulf_stream_lat2[:-1],
              x1=gulf_stream_lon2[1:], y1=gulf_stream_lat2[1:],
              color='red', line_alpha=0.5, line_width=2)

    p.legend.location = "top_left"

    # DataFrame display
    no_cols = ['x_start', 'x_end', 'y_start', 'y_end', 'Distance_draw']
    cols = [TableColumn(field=col, title=col) for col in df_spawn_end.columns if col not in no_cols]
    data_table = DataTable(columns=cols, source=source, width=1100, selectable=False)

    # ------------------------------------------------------------------------
    # UPDATING FIRST TAB
    # ------------------------------------------------------------------------

    # updating process of the data underlying the map depending on user actions.
    def update_map_se(attr, old, new):

        yr = slider_year.value
        month = slider_month.value
        zone = select_zone.value
        n = select_number.value
        n = int(n)

        if zone == 'All':
            df_temp = df_spawn_end.loc[(df_spawn_end['Year_start'] >= yr[0])
                                       & (df_spawn_end['Year_start'] <= yr[1])
                                       & (df_spawn_end['Month_start'] >= month[0])
                                       & (df_spawn_end['Month_start'] <= month[1])]

        else:
            df_temp = df_spawn_end.loc[(df_spawn_end.Zones_start == zone)
                                       & (df_spawn_end['Year_start'] >= yr[0])
                                       & (df_spawn_end['Year_start'] <= yr[1])
                                       & (df_spawn_end['Month_start'] >= month[0])
                                       & (df_spawn_end['Month_start'] <= month[1])]

        if n == -1:

            source.data = ColumnDataSource.from_df(df_temp)
        else:

            if n > len(df_temp):  # For cases where there are not enough data points
                n = int(len(df_temp))

            np.random.seed(42)

            select_list = list(np.random.choice(df_temp.index, size=n, replace=False))

            filtr = df_temp.index.map(lambda x: x in select_list)

            source.data = ColumnDataSource.from_df(df_temp.loc[filtr])

    def month_active(atrr, old, new):

        active = toggle_month.active
        dist = toggle_dist_month.active

        if not active:

            c2.visible, s1.visible = False, False
            toggle_month.label = "Show end points"

        else:

            c2.visible, s1.visible = True, True
            toggle_month.label= "Unshow end points"

        if not dist:

            c1.visible, d1.visible = True, False
            toggle_dist_month.label = "Show distance traveled"

        else:

            c1.visible, d1.visible = False, True
            toggle_dist_month.label = "Unshow distance traveled"

    # activation of the changes on user action
    select_number.on_change('value', update_map_se)
    slider_year.on_change('value', update_map_se)
    slider_month.on_change('value', update_map_se)
    select_zone.on_change('value', update_map_se)
    toggle_month.on_change('active', month_active)
    toggle_dist_month.on_change('active', month_active)

    # Make first tab
    tab_month = Panel(child=column(row(column(slider_year, slider_month,
                                       select_number, select_zone,
                                       toggle_month, toggle_dist_month), p, add_paragraph), data_table), title="Monthly")

    # ----------------------------------------------------------------------------
    # SECOND TAB
    # ----------------------------------------------------------------------------

    p_season = figure(tools='pan, wheel_zoom', x_range=(lon_boundaries[0], lon_boundaries[1]),
                      y_range=(lat_boundaries[0], lat_boundaries[1]),
                      x_axis_type="mercator", y_axis_type="mercator")

    p_season.add_tile(WMTSTileSource(url=url, attribution=attribution))

    # Add data points
    # - Start
    # - End
    # - Start with size adjusted to the traveled distance
    c3 = p_season.circle(x='x_start', y='y_start', fill_color='green', size=8,
                         source=source, legend_label='Start points')

    c4 = p_season.circle(x='x_end', y='y_end', fill_color='orange', size=8,
                         source=source, legend_label='End points')

    d2 = p_season.circle(x='x_start', y='y_start', fill_color='green', radius='Distance_draw',
                         source=source)

    # line between start and end points
    s2 = p_season.segment(x0='x_start', y0='y_start', x1='x_end', y1='y_end',
                          line_dash='dashed', source=source)

    # Initial configuration of WIDGETS  for SECOND TAB
    # - Don't show end points
    # - Don't show segments between start and end points
    # - Uniform size for starting points
    c4.visible, s2.visible, d2.visible = False, False, False

    # Configuration of the hovertool
    hover_season = HoverTool(tooltips=[("ID", "@ID"), ("Duration", "@Duration"),
                                       ("Distance", "@Distance")],
                             renderers=[c3, c4], formatters={'Duration': 'printf'})
    p_season.tools.append(hover_season)

    # Gulf Stream
    p_season.segment(x0=gulf_stream_lon1[:-1], y0=gulf_stream_lat1[:-1],
                     x1=gulf_stream_lon1[1:], y1=gulf_stream_lat1[1:],
                     legend_label='Gulf Stream', color='red', line_alpha=0.5, line_width=2)

    p_season.segment(x0=gulf_stream_lon2[:-1], y0=gulf_stream_lat2[:-1],
                     x1=gulf_stream_lon2[1:], y1=gulf_stream_lat2[1:],
                     color='red', line_alpha=0.5, line_width=2)

    p_season.legend.location = "top_left"

    # ------------------------------------------------------------------------
    # UPDATING SECOND TAB
    # ------------------------------------------------------------------------

    # updating process of the data underlying the map depending on user actions.
    def update_map_season(attr, old, new):

        yr = slider_year_season.value
        season = select_season.value
        zone = select_zone_season.value
        n = select_number_season.value
        n = int(n)

        if (zone == 'All') & (season == 'All'):
            df_temp = df_spawn_end.loc[(df_spawn_end['Year_start'] >= yr[0])
                                       & (df_spawn_end['Year_start'] <= yr[1])]

        elif (zone != 'All') & (season == 'All'):
            df_temp = df_spawn_end.loc[(df_spawn_end.Zones_start == zone)
                                       & (df_spawn_end['Year_start'] >= yr[0])
                                       & (df_spawn_end['Year_start'] <= yr[1])]

        elif (zone == 'All') & (season != 'All'):
            df_temp = df_spawn_end.loc[(df_spawn_end.Season_start == season)
                                       & (df_spawn_end['Year_start'] >= yr[0])
                                       & (df_spawn_end['Year_start'] <= yr[1])]

        else:
            df_temp = df_spawn_end.loc[(df_spawn_end.Zones_start == zone)
                                       & (df_spawn_end.Season_start == season)
                                       & (df_spawn_end['Year_start'] >= yr[0])
                                       & (df_spawn_end['Year_start'] <= yr[1])]

        if n == -1:

            source.data = ColumnDataSource.from_df(df_temp)
        else:

            if n > len(df_temp):  # For cases where there are not enough data points
                n = int(len(df_temp))

            np.random.seed(42)

            select_list = list(np.random.choice(df_temp.index, size=n, replace=False))

            filtr = df_temp.index.map(lambda x: x in select_list)

            source.data = ColumnDataSource.from_df(df_temp.loc[filtr])

    def season_active(atrr, old, new):

        active = toggle_season.active
        dist = toggle_dist_season.active

        if not active:

            c4.visible, s2.visible = False, False
            toggle_season.label = "Show end points"

        else:

            c4.visible, s2.visible = True, True
            toggle_season.label = "Show end points"

        if not dist:

            c3.visible, d2.visible = True, False
            toggle_dist_season.label = "Show distance traveled"

        else:

            c3.visible, d2.visible = False, True
            toggle_dist_season.label = "Unshow distance traveled"

    select_number_season.on_change('value', update_map_season)
    slider_year_season.on_change('value', update_map_season)
    select_season.on_change('value', update_map_season)
    select_zone_season.on_change('value', update_map_season)
    toggle_season.on_change('active', season_active)
    toggle_dist_season.on_change('active', season_active)

    # Make second tab
    tab_season = Panel(child=column(row(column(slider_year_season, select_number_season, select_season,
                                        select_zone_season,toggle_season, toggle_dist_season),
                                        p_season, add_paragraph), data_table), title="Seasonal")

    # ----------------------------------------------------------------------------
    # FINAL SET UP
    # ----------------------------------------------------------------------------

    tabs = Tabs(tabs=[tab_month, tab_season])

    def tab_change(atrr, old, new):

        if tabs.active == 0:

            update_map_se('', '', '')

        else:

            update_map_season('', '', '')

    tabs.on_change('active', tab_change)

    # Make document
    doc.add_root(tabs)
    doc.title = 'Hurricanes'
    doc.theme = Theme(filename="theme.yaml")
Beispiel #19
0
from bokeh.models.widgets import Toggle
from bokeh.io import output_file, show, vform

output_file("toggle.html")

toggle = Toggle(label="Foo", type="success")

show(vform(toggle))
Beispiel #20
0
                               formatter=NumberFormatter(format="0.000")),
                           TableColumn(field="v",
                                       title="voltage (V/1023)",
                                       editor=IntEditor(step=1)),
                       ])

##############################################################################
# Widgets

_div = Div(text=""" """, height=4)
checkbox = CheckboxGroup(labels=['', '', ''], active=[0])
device_slc = Select(title="Device ID:",
                    value=g.device_id,
                    options=DEVICES['code'])
device_conn_btn = Toggle(label="Connect to device",
                         button_type="success",
                         active=True)
read_point_btn = Button(label="Read point", button_type="primary")
clear_points_btn = Button(label="Clear selected points", button_type="warning")
clear_everything_btn = Button(label="Clear everything", button_type="danger")
calibrate_btn = Button(label="Get calibration curve", button_type="success")
save_btn = Button(label="Save calibration", button_type="primary")
export_btn = Button(label="Export points", button_type="success")


# Select: esp device selection by Id
def device_slc_callback(attr, old, new):
    g.device_id = new
    g.d_idx = DEVICES['code'].index(g.device_id)

    if conn_status.value:
Beispiel #21
0
                y='y',
                source=source1,
                selection_fill_color='Black',
                nonselection_fill_color='Gray')

    # table with points in subset
    columns = [
        TableColumn(field="x", title="X"),
        TableColumn(field="z", title="Text"),
    ]
    data_table = DataTable(source=source2,
                           columns=columns,
                           width=400,
                           height=280)

    button = Toggle(label="Select")
    button.callback = CustomJS(args=dict(source1=source1, source2=source2),
                               code="""
                                       var inds_in_source2 =
                               source2.get('selected')['1d'].indices;
                                       var d = source2.get('data');
                                       var inds = []
                                       
                                       if (inds_in_source2.length == 0) { return; }

                                       for (i = 0; i < inds_in_source2.length; i++)
                               {
                                           inds.push(d['index'][i])
                                       }

                                       source1.get('selected')['1d'].indices = inds
Beispiel #22
0
def ToggleWidget(*args, **kw):
    kw['active'] = kw.pop('value')
    kw['label'] = kw.pop('title')
    return Toggle(*args, **kw)
Beispiel #23
0
slider_time_unit_mapping = {0: "hour", 1: "day", 2: "month"}
# create plots
map_figure, map_glyph = _create_choropleth_map(geo_source,
                                               width=LEFT_COLUMN_WIDTH,
                                               height=700)

ts_figure, ts_glyph = _create_time_series(\
                        dfincident, "Hour", "Daily", "None",
                        dfincident["dim_incident_incident_type"].unique(),
                        width=600, height=350)

# create widgets
slider_time_unit = "hour"
time_slider = create_slider(slider_time_unit)
slider_active_toggle = Toggle(label="slider not active",
                              active=False,
                              button_type="default",
                              width=150)
pattern_select = _create_radio_button_group(["Daily", "Weekly", "Yearly"])
aggregate_select = _create_radio_button_group(["Hour", "Day", "Week", "Month"])
groupby_select = _create_radio_button_group(
    ["None", "Type", "Day of Week", "Year"])
incident_types = dfincident["dim_incident_incident_type"].astype(str).unique()
#type_filter = _create_type_filter(incident_types)
type_filter = MultiSelect(title="Incident Types:",
                          value=list(incident_types),
                          options=[(t, t) for t in incident_types],
                          size=10)
select_all_types_button = Button(label="Select all",
                                 button_type="primary",
                                 width=150)
Beispiel #24
0
    CheckboxButtonGroup,
    RadioButtonGroup,
)

button = Button(label="Button (enabled) - has click event",
                button_type="primary")
button.js_on_click(
    CustomJS(code="console.log('button: click ', this.toString())"))

button_disabled = Button(label="Button (disabled) - no click event",
                         button_type="primary",
                         disabled=True)
button_disabled.js_on_click(
    CustomJS(code="console.log('button(disabled): click ', this.toString())"))

toggle_inactive = Toggle(label="Toggle button (initially inactive)",
                         button_type="success")
toggle_inactive.js_on_click(
    CustomJS(
        code=
        "console.log('toggle(inactive): active=' + this.active, this.toString())"
    ))

toggle_active = Toggle(label="Toggle button (initially active)",
                       button_type="success",
                       active=True)
toggle_active.js_on_click(
    CustomJS(
        code=
        "console.log('toggle(active): active=' + this.active, this.toString())"
    ))
Beispiel #25
0
x_field = Select(title="X-Axis Value",
                 options=sorted([(key, val) for (key, val) in cols.items()
                                 if key not in removed_columns],
                                key=lambda x: x[1]),
                 value='corresponding_wt_score'
                 if 'corresponding_wt_score' in cols.keys() else 'wt_ic50')
widgets.append(x_field)
y_field = Select(
    title='Y-Axis Value',
    options=sorted(
        [(key, val)
         for (key, val) in cols.items() if key not in removed_columns],
        key=lambda x: x[1]),
    value='best_mt_score' if 'best_mt_score' in cols.keys() else 'mt_ic50')
widgets.append(y_field)
hide_null = Toggle(active=True,
                   label="Hide 0 results with null X or Y axis values")
widgets.append(hide_null)

# Set up the data dictionary (a transposed version of entries)
data_dict = {key: [] for key in cols}
data_dict.update({
    '_x': [],
    '_y': [],
})

source = ColumnDataSource(
    data=data_dict)  #wrap a datasource around the dictionary
source.tags = [
    sample
]  # save sample name to tags to access for naming downloaded CSV files
Beispiel #26
0
def radio_group_handler(active):
    print("radio_group_handler: %s" % active)
    session.store_document(document)

def checkbox_button_group_handler(active):
    print("checkbox_button_group_handler: %s" % active)
    session.store_document(document)

def radio_button_group_handler(active):
    print("radio_button_group_handler: %s" % active)
    session.store_document(document)

button = Button(label="Push button", icon=Icon(name="check"), type="primary")
button.on_click(button_handler)

toggle = Toggle(label="Toggle button", type="success")
toggle.on_click(toggle_handler)

menu = [("Item 1", "item_1"), ("Item 2", "item_2"), None, ("Item 3", "item_3")]
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)
Beispiel #27
0
    var state = cb_obj.active
    var data = source.data
    var leg = leg_source.data
    if (state){
    data['color'] = data['cb_colors'];
    leg['colors'] = color_source['cb'];
    } else{
    data['color'] = data['def_colors'];
    leg['colors'] = color_source['reg'];
    }
    source.change.emit();
    leg_source.change.emit();    
    """)

color_toggle = Toggle(label="Colorblind Mode",
                      button_type="success",
                      callback=clr_callback,
                      width=200)

### Plotting
p_tools = "hover, wheel_zoom, box_zoom, reset"
p = figure(title="Amount per 100g",
           tools=p_tools,
           plot_width=900,
           x_range=(-50, 1050),
           x_axis_label='Calories',
           y_range=(-5, 105),
           y_axis_label='Protein (g)',
           sizing_mode='scale_width')

p.circle(x='x',
         y='y',
Beispiel #28
0
from bokeh.document import Document
from bokeh.embed import file_html
from bokeh.resources import INLINE

from bokeh.models import CustomJS, WidgetBox
from bokeh.models.widgets import (
    Button, Toggle, Dropdown, CheckboxGroup, RadioGroup, CheckboxButtonGroup, RadioButtonGroup,
)

button = Button(label="Button (enabled) - has click event", button_type="primary")
button.js_on_click(CustomJS(code="console.log('button: click', this.toString())"))

button_disabled = Button(label="Button (disabled) - no click event", button_type="primary", disabled=True)
button_disabled.js_on_click(CustomJS(code="console.log('button_disabled: click', this.toString())"))

toggle_inactive = Toggle(label="Toggle button (initially inactive)", button_type="success")
toggle_inactive.js_on_click(CustomJS(code="console.log('toggle_inactive: ' + this.active, this.toString())"))

toggle_active = Toggle(label="Toggle button (initially active)", button_type="success", active=True)
toggle_active.js_on_click(CustomJS(code="console.log('toggle_active: ' + this.active, this.toString())"))

menu = [("Item 1", "item_1_value"), ("Item 2", "item_2_value"), None, ("Item 3", "item_3_value")]

dropdown = Dropdown(label="Dropdown button", button_type="warning", menu=menu)
dropdown.js_on_click(CustomJS(code="console.log('dropdown: ' + this.value, this.toString())"))

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())"))
Beispiel #29
0
    nvote_slider = Slider(start=0,
                          end=end_slider,
                          value=0,
                          step=10,
                          title="Nombre de votes minimum",
                          callback=filtervote)
    filtervote.args["nvote"] = nvote_slider
    vote_slider = Slider(start=50,
                         end=100,
                         value=50,
                         title="Approbation/rejet(%)",
                         callback=filtervote)
    filtervote.args["vote"] = vote_slider

    toggle = Toggle(label="Cacher points non significatifs",
                    callback=filtervote,
                    width=50)
    toggle_expl = Div(
        text=
        """Ce bouton masque les propositions dont l'approbation <b>ne peut pas être distinguée statistiquement de 50%</b>. Par exemple, une approbation de 60% ne veut presque rien dire si on la calcule sur 10 votes, par contre sur 5000 on est sûr qu'une majorité des votants est d'accord avec la proposition.Formellement, ce filtrage est obtenu par un test binomial exact bi-directionnel avec correction de Bonferroni."""
    )
    toggletxt = Toggle(label="Afficher le titre des revendications",
                       callback=filtervote,
                       width=50)
    toggletxt_exp = Div(
        text=
        """<b>Attention:</b> Filtrer les points et/ou zoomer avant d'afficher le texte pour que le graphique reste lisible."""
    )
    filtervote.args["ci"] = toggle
    filtervote.args["txt"] = toggletxt
t2 = p.text(zmin+1.5, 1.3, text=['\u03BB = u/f = {} m'.format(wavelength_m)], text_align="left", text_font_size="10pt")
t3 = p.text(zmin+1.5, 1.7, text=['u = {:.1e} m/s'.format(velocity_mps)], text_align="left", text_font_size="10pt")

# Set up toggle button & callback function
def toggle_handler(active):
    if active:
        toggle.label = 'Stop'
        checkbox_group.disabled = True
        #t3.data_source.data["text"] = ['Running']
        curdoc().add_periodic_callback(update, periodic_callback_time_ms)
    else:
        toggle.label = 'Start'
        checkbox_group.disabled = False
        #t3.data_source.data["text"] = ['Stopped']
        curdoc().remove_periodic_callback(update)
toggle = Toggle(label="Start", type="success")
toggle.on_click(toggle_handler)
toggle.active = False

# Set up reset button
def reset_handler():
    global ii, current_time
    ii = 0
    current_time = 0
    l_forward.data_source.data["y"] = forward_wave()
    l_reverse.data_source.data["y"] = reverse_wave()
    l_sum.data_source.data["y"] = l_forward.data_source.data["y"] + \
                                  l_reverse.data_source.data["y"]
    #t2.data_source.data["text"] = ['t = {:.3f} s'.format(current_time)]
button_reset = Button(label="Reset", type="success")
button_reset.on_click(reset_handler)
Beispiel #31
0
x = Select(title='X-Axis', value=X_INIT, options=continuous)
# link widget callback to update_plot()
x.on_change('value', update_plot)

# create y-axis dropdown widget with continuous var columns
y = Select(title='Y-Axis', value=Y_INIT, options=continuous)
# link widget callback to update_plot()
y.on_change('value', update_plot)

# create dot color dropdown widget with "countable" var columns
color = Select(title='Color', value=COLOR_INIT, options=countable)
# link widget callback to update_plot()
color.on_change('value', update_plot)

# create image glyph toggle button
toggle = Toggle(label="Show Images", button_type="success")
# link button callback to toggle_callback()
toggle.on_click(toggle_callback)

# create lasso
lasso = LassoSelectTool()

# download button
button = Button(label="Download", button_type="success")

# button.callback = download_callback()
button.callback = CustomJS(args=dict(source=source),
                           code=open(join(dirname(__file__),
                                          "download.js")).read())

# add button and dropdown selections to a widgetbox
Beispiel #32
0
from bokeh.models import CustomJS
from bokeh.models.layouts import WidgetBox
from bokeh.models.widgets import (
    Button, Toggle, Dropdown, CheckboxGroup, RadioGroup,
    CheckboxButtonGroup, RadioButtonGroup,
)

button = Button(label="Button (enabled) - has click event", button_type="primary")
button.on_click(lambda: print('button: click'))
button.js_on_click(CustomJS(code="console.log('button: click', this.toString())"))

button_disabled = Button(label="Button (disabled) - no click event", button_type="primary", disabled=True)
button_disabled.on_click(lambda: print('button_disabled: click'))
button_disabled.js_on_click(CustomJS(code="console.log('button_disabled: click', this.toString())"))

toggle_inactive = Toggle(label="Toggle button (initially inactive)", button_type="success")
toggle_inactive.on_click(lambda value: print('toggle_inactive: %s' % value))
toggle_inactive.js_on_click(CustomJS(code="console.log('toggle_inactive: ' + this.active, this.toString())"))

toggle_active = Toggle(label="Toggle button (initially active)", button_type="success", active=True)
toggle_active.on_click(lambda value: print('toggle_active: %s' % value))
toggle_active.js_on_click(CustomJS(code="console.log('toggle_active: ' + this.active, this.toString())"))

menu = [("Item 1", "item_1_value"), ("Item 2", "item_2_value"), None, ("Item 3", "item_3_value")]

dropdown = Dropdown(label="Dropdown button", button_type="warning", menu=menu)
dropdown.on_click(lambda value: print('dropdown: %s' % value))
dropdown.js_on_click(CustomJS(code="console.log('dropdown: ' + this.value, this.toString())"))

dropdown_disabled = Dropdown(label="Dropdown button (disabled)", button_type="warning", menu=menu)
dropdown_disabled.on_click(lambda value: print('dropdown_disabled: %s' % value))
Beispiel #33
0
    DateRangeSlider,
    DatePicker,
    Paragraph,
    Div,
    PreText,
    Panel,
    Tabs,
)
from bokeh.plotting import figure
from bokeh.sampledata.iris import flowers

button = Button(label="Button (disabled) - still has click event",
                button_type="primary",
                disabled=True)

toggle = Toggle(label="Toggle button", button_type="success")

menu = [("Item 1", "item_1_value"), ("Item 2", "item_2_value"),
        ("Item 3", "item_3_value")]
dropdown = Dropdown(label="Dropdown button",
                    button_type="warning",
                    menu=menu,
                    default_value="item_1_value")

split_menu = [("Item 1", "item_1_value"), ("Item 2", "item_2_value"), None,
              ("Item 3", "item_3_value")]
split = Dropdown(label="Split button", button_type="danger", menu=split_menu)

checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"],
                               active=[0, 1])
Beispiel #34
0
N_HOST = Select(title='Neighbourhood:',
                value=c.EMPTY_STRING,
                options=[c.EMPTY_STRING] + FILTER_PROPERTIES[c.NC])
NG_HOST = Select(title='Neighbourhood Group:',
                 value=c.EMPTY_STRING,
                 options=[c.EMPTY_STRING] + NG_LIST)
ROOM_TYPE_HOST = Select(title='Room Type:',
                        value=c.EMPTY_STRING,
                        options=[c.EMPTY_STRING] + RT_LIST)

# Radio Button Widget
USER_TYPE = RadioButtonGroup(labels=['Guest', 'Host'], active=0)
USER_TYPE.on_change(c.ACTIVE, update_layout)

# Button Toggle Widget
PREDICT_VALUE = Toggle(label='Submit', button_type='success')
PREDICT_VALUE.on_click(predict_price)

# Text Widget
HOST_PRICE = Paragraph(text="""Select all listing values and press
                        submit to view your listings valued price.""",
                       width=500,
                       height=500)

WIDGETS_BOTH_1 = [USER_TYPE, CITY_INPUT]
WIDGETS_BOTH_2 = [
    ACCOMMODATES_SLIDER, BEDROOM_SLIDER, BED_SLIDER, BATHROOM_SLIDER
]
WIDGETS_BOTH_3 = [AMENITIES_SELECT]

WIDGETS_GUEST = widgetbox(
Beispiel #35
0
)

button = Button(label="Button (enabled) - has click event",
                button_type="primary")
button.on_click(lambda: print('button: click'))
button.js_on_click(
    CustomJS(code="console.log('button: click', this.toString())"))

button_disabled = Button(label="Button (disabled) - no click event",
                         button_type="primary",
                         disabled=True)
button_disabled.on_click(lambda: print('button_disabled: click'))
button_disabled.js_on_click(
    CustomJS(code="console.log('button_disabled: click', this.toString())"))

toggle_inactive = Toggle(label="Toggle button (initially inactive)",
                         button_type="success")
toggle_inactive.on_click(lambda value: print('toggle_inactive: %s' % value))
toggle_inactive.js_on_click(
    CustomJS(
        code="console.log('toggle_inactive: ' + this.active, this.toString())")
)

toggle_active = Toggle(label="Toggle button (initially active)",
                       button_type="success",
                       active=True)
toggle_active.on_click(lambda value: print('toggle_active: %s' % value))
toggle_active.js_on_click(
    CustomJS(
        code="console.log('toggle_active: ' + this.active, this.toString())"))

menu = [("Item 1", "item_1_value"), ("Item 2", "item_2_value"), None,
def forceSaveFilename_InputChange(attr, old, new):
    if "." not in new:
        force_save_filename_input.value = new + ".h5"
    elif new.split(".")[-1] != "h5":
        force_save_filename_input.value = old

def loadFile_InputChange(attr, old, new):
    if not os.path.isfile(new):
        load_file_input.value = old



#Initialize Widgets
# toggle buttons
all_off_button = Toggle(label="All Off", button_type="warning")
all_on_button = Toggle(label="All On", button_type="warning")
reset_button = Toggle(label="Reset Scope", button_type="warning")
autoscale_button = Toggle(label="AutoScale Scope", button_type="warning")
pulse_capture_button = Toggle(label="Pulse Capture", button_type="success")
auto_save_button = Toggle(label="Stop Auto Save", button_type="warning")
load_button = Toggle(label="Load", button_type="success")
force_save_button = Toggle(label="Force Save", button_type="warning")
save_PC_button = Toggle(label="Save", button_type="warning")


# Single select dropdown menus
acq_period_select = Select(title="Acquisition Period (s):", value="100",
                        options=[".5","1","10","100","300","1000"])
num_avgs_select = Select(title="Number of Points to Average:", value="100", 
                        options=["100","1000","10000","100000","1000000"])