bokeh.models.Spacer

    def __do_layout(self):
        # TODO: Generalize for 1 or 2 groups
        self.layout = column(row(self.select_y, self.select_linac[1], self.select_linac[2], self.avg_len_input,
                                 self.percentile_input, self.bins_input),
                             row(self.select_energies[1], self.select_energies[2]),
                             row(self.start_date_picker, self.end_date_picker),
                             row(Div(text='Gamma Criteria: '), self.checkbox_button_group),
                             self.div_summary[1],
                             self.div_summary[2],
                             row(Spacer(width=10), self.fig),
                             Spacer(height=50),
                             row(Spacer(width=10), self.histogram),
                             Spacer(height=50),
                             row(Spacer(width=10), self.ichart),
                             row(self.div_center_line[1], self.div_ucl[1], self.div_lcl[1]),
                             row(self.div_center_line[2], self.div_ucl[2], self.div_lcl[2]))

    def update_source_ticker(self, attr, old, new):

def _figure_rows(
    model_evaluations: Sequence[Evaluation], include_spacer: Optional[bool],
) -> Sequence[Row]:
    # TODO check figure consistency
    rows = []
    for i_figure, _ in enumerate(model_evaluations[0].lazy_figures):
        row_of_figures = [
            evaluation.lazy_figures[i_figure]()
            for i_model, evaluation in enumerate(model_evaluations)
        ]
        if len(model_evaluations) == 1 and include_spacer in (None, True):
            row_of_figures = row_of_figures + [Spacer()]
        elif include_spacer is True:
            row_of_figures = [Spacer()] + row_of_figures
        rows.append(bokeh.layouts.row(row_of_figures, sizing_mode="scale_width"))
    return rows


def _format_numbers(entry: Any) -> Any:

def getRunButtonsBar(runact,abortact,pauseact,resumeact,timercb):
  runstopbut = getRunStopButton()
  pauseresumebut = getPauseResumeButton()
  pauseresumebut.visible = False
  buttonsgrp = row(pauseresumebut,Spacer(width=but_spacer),runstopbut,width_policy='min')
  buttonsfld = row(Spacer(width=but_spacer),buttonsgrp, sizing_mode='stretch_width')
  ret = {
    'run': runstopbut,
    'pause': pauseresumebut,
    'state': RunState.Ready,
    timerkey: None
  }
  runstopbut.on_click(partial(startStopCB,cb=ret,run_fn=runact,abort_fn=abortact,
                              timer_fn=timercb) )
  pauseresumebut.on_click(partial(pauseResumeCB,cb=ret,pause_fn=pauseact,resume_fn=resumeact))
  return buttonsfld

def startStopCB( cb, run_fn, abort_fn, timer_fn, repeat=2000 ):

def month(month):

    f'''
    # Month: {month}
    '''

    '''
    $contents
    '''

    '''
    ## Preparation
    '''
    
    s = session('-v2')
    output_file(filename='/dev/null')
    map_size = 100
    month_start = to_date(month).replace(day=1)

    '''
    ## Generate Plot
    '''

    def days():

        for i in Calendar().iterweekdays():
            yield Div(text=f'  <  h2>{day_name[i]} < /h2>')

        day = month_start - dt.timedelta(days=month_start.weekday())
        while day.replace(day=1)  < = month_start:
            for weekday in range(7):
                if day.month == month_start.month:
                    contents = [Div(text=f' < h1>{day.strftime("%d")} < /h1>')]
                    for a in s.query(ActivityJournal). \
                            filter(ActivityJournal.start >= local_date_to_time(day),
                                   ActivityJournal.start  <  local_date_to_time(day + dt.timedelta(days=1))).all():
                        df = Statistics(s, activity_journal=a). \
                            by_name(ActivityReader, N.SPHERICAL_MERCATOR_X, N.SPHERICAL_MERCATOR_Y).df
                        contents.append(map_thumbnail(map_size, map_size, df, title=False))
                        df = Statistics(s, activity_journal=a). \
                            by_name(ActivityCalculator, N.ACTIVE_DISTANCE, N.ACTIVE_TIME).df
                        contents.append(Div(
                            text=f'{format_km(df[N.ACTIVE_DISTANCE][0])} {format_seconds(df[N.ACTIVE_TIME][0])}'))
                else:
                    contents = [Spacer()]
                yield column(contents)
                day += dt.timedelta(days=1)

    show(grid(list(days()), ncols=7))

def sw_industry_analysis():

    def nix(val, lst):
        return [x for x in lst if x != val]

    def get_data(ticker_1, ticker_2, start='20180101', end=datetime.today().date()):
        df = get_price([ticker_1, ticker_2], start, end, fields='close')
        df['t1_returns'] = np.log(df[ticker_1]).diff()
        df['t2_returns'] = np.log(df[ticker_2]).diff()
        return df.dropna().reset_index()

    def get_hhist_data(data):
        hhist, hedges = np.histogram(data['t1_returns'], bins=20)
        hzeros = np.zeros_like(hhist)
        hhist_data = {'left': hedges[:-1], 'right': hedges[1:], 'bottom': hzeros,
                      'top': hhist, 'top_1': hzeros, 'top_2': hzeros}
        return hhist_data

    def get_vhist_data(data):
        vhist, vedges = np.histogram(data['t2_returns'], bins=20)
        vzeros = np.zeros_like(vhist)
        vhist_data = {'left': vzeros, 'right': vhist, 'bottom': vedges[:-1],
                      'top': vedges[1:], 'right_1': vzeros, 'right_2': vzeros}
        return vhist_data

    def ticker1_change(attr, old, new):
        ticker_2.options = nix(new, DEFAULT_TICKERS)
        update()

    def ticker2_change(attr, old, new):
        ticker_1.options = nix(new, DEFAULT_TICKERS)
        update()

    def update():
        global df
        ticker_1_name, ticker_2_name = SHENWAN_INDUSTRY_MAP_[ticker_1.value], SHENWAN_INDUSTRY_MAP_[ticker_2.value]
        df = get_data(ticker_1_name, ticker_2_name)

        source.data.update(dict(x=df['t1_returns'], y=df['t2_returns'], x_p=df[ticker_1_name],
                                y_p=df[ticker_2_name], date=df['date']))

        hhist_data_dict = get_hhist_data(df)
        source_hhist.data.update(hhist_data_dict)
        hmax = max(source_hhist.data['top']) * 1.1
        ph.y_range.update(start=-hmax, end=hmax)
        print('ph.y_range', ph.y_range.end)

        vhist_data_dict = get_vhist_data(df)
        source_vhist.data.update(vhist_data_dict)
        vmax = max(source_vhist.data['right']) * 1.1
        pv.x_range.update(start=vmax, end=-vmax)
        print('pv.x_range', pv.x_range.end)
        print(20 * '=')

        update_stats(df, ticker_1_name, ticker_2_name)

        corr.title.text = "{} vs. {}".format(ticker_1.value, ticker_2.value)
        ts1.title.text = ticker_1.value
        ts2.title.text = ticker_2.value

    def udpate_selection(attr, old, new):
        inds = new  # 选定的数据对应的索引
        length = len(df)
        if 0   <   len(inds)  <  length:
            neg_inds = [s for s in range(length) if s not in inds]  # 未选定数据点的对应索引
            _, hedges = np.histogram(df['t1_returns'], bins=20)
            _, vedges = np.histogram(df['t2_returns'], bins=20)

            new_hhist_df = df['t1_returns']
            new_vhist_df = df['t2_returns']

            hhist1, _ = np.histogram(new_hhist_df.iloc[inds], bins=hedges)
            hhist2, _ = np.histogram(new_hhist_df.iloc[neg_inds], bins=hedges)

            vhist1, _ = np.histogram(new_vhist_df.iloc[inds], bins=vedges)
            vhist2, _ = np.histogram(new_vhist_df.iloc[neg_inds], bins=vedges)

            source_hhist.patch({'top_1': [(slice(None), hhist1)], 'top_2': [(slice(None), -hhist2)]})
            source_vhist.patch({'right_1': [(slice(None), vhist1)], 'right_2': [(slice(None), -vhist2)]})

    def update_stats(data, t1, t2):
        stats_indicator = data[[t1, t2, 't1_returns', 't2_returns']].describe()
        ticker_1_name, ticker_2_name = ticker_1.value, ticker_2.value
        stats_indicator.columns = [ticker_1_name, ticker_2_name, ticker_1_name + '收益率', ticker_2_name + '收益率']
        stats.text = str(stats_indicator)

    # Set Up Widgets
    stats = PreText(text='', width=700)
    ticker_1 = Select(value='非银金融', options=nix('食品饮料', DEFAULT_TICKERS))
    ticker_2 = Select(value='食品饮料', options=nix('非银金融', DEFAULT_TICKERS))

    # Callback
    ticker_1.on_change('value', ticker1_change)
    ticker_2.on_change('value', ticker2_change)

    # Construct DataSource
    source = ColumnDataSource(data=dict(x=[], y=[], x_p=[], y_p=[], date=[]))
    source_hhist = ColumnDataSource(data=dict(left=[], right=[], bottom=[], top=[], top_1=[], top_2=[]))
    source_vhist = ColumnDataSource(data=dict(left=[], right=[], bottom=[], top=[], right_1=[], right_2=[]))

    # 收益率散点图
    corr = figure(plot_width=500, plot_height=500, tools=TOOLS)
    r = corr.scatter(x='x', y='y', size=2, source=source, selection_color='orange', alpha=0.6,
                     nonselection_alpha=0.1, selection_alpha=0.4)

    # 添加横轴直方图
    hmax = 40
    ph = figure(toolbar_location=None, plot_width=corr.plot_width, plot_height=200, y_range=(-hmax, hmax),
                min_border=10, min_border_left=None, y_axis_location='left', x_axis_location='above')
    ph.quad(bottom='bottom', top='top', left='left', right='right', color='white', line_color="#3A5785",
            source=source_hhist)
    ph.quad(bottom='bottom', top='top_1', left='left', right='right', alpha=0.5, source=source_hhist, **LINE_ARGS)
    ph.quad(bottom='bottom', top='top_2', left='left', right='right', alpha=0.1, source=source_hhist, **LINE_ARGS)

    ph.xgrid.grid_line_color = None
    ph.yaxis.major_label_orientation = np.pi / 4
    ph.background_fill_color = '#fafafa'

    # 添加纵轴直方图
    vmax = 40
    pv = figure(toolbar_location=None, plot_height=corr.plot_height, plot_width=200, x_range=(vmax, -vmax),
                min_border=10, min_border_left=None, y_axis_location='left')
    pv.quad(bottom='bottom', top='top', left='left', right='right', color='white', line_color="#3A5785",
            source=source_vhist)
    pv.quad(bottom='bottom', top='top', left='left', right='right_1', alpha=0.5, source=source_vhist, **LINE_ARGS)
    pv.quad(bottom='bottom', top='top', left='left', right='right_2', alpha=0.1, source=source_vhist, **LINE_ARGS)

    # 股价时间序列图
    ts1 = figure(plot_width=900, plot_height=200, tools=TOOLS, x_axis_type='datetime', active_drag='box_select',
                 toolbar_location='above')
    ts1.line('date', 'x_p', source=source)
    ts1.circle('date', 'x_p', size=1, source=source, color=None, selection_color='orange')

    ts2 = figure(plot_width=ts1.plot_width, plot_height=ts1.plot_height, tools=TOOLS, x_axis_type='datetime',
                 active_drag='box_select', toolbar_location='above')
    ts2.x_range = ts1.x_range
    ts2.line('date', 'y_p', source=source)
    ts2.circle('date', 'y_p', size=1, source=source, color=None, selection_color='orange')

    # 初始化数据
    update()

    r.data_source.selected.on_change('indices', udpate_selection)

    widgets = column(ticker_1, ticker_2, widgetbox(stats))
    layout_1 = column(row(Spacer(width=200, height=200), ph), row(pv, corr, widgets))

    layout_2 = column(layout_1, ts1, ts2)

    tab = Panel(child=layout_2, title='IndustryAnalysis')

    return tab

# tabs = Tabs(tabs=[sw_industry_analysis()])
# curdoc().add_root(tabs)

    def _createmodel(self):

        def on_select_filter(self, a, old, new):
            _logger.debug(f'Switching filter to {new}...')
            # ensure datahandler is stopped
            self._datahandler.stop()
            self._filter = new
            self.updatemodel()
            _logger.debug('Switching filter finished')

        def on_click_nav_action(self):
            if not self._paused:
                self._pause()
            else:
                self._resume()
            refresh(self)

        def on_click_nav_prev(self, steps=1):
            self._pause()
            self._set_data_by_idx(self._datahandler.get_last_idx() - steps)
            update_nav_buttons(self)

        def on_click_nav_next(self, steps=1):
            self._pause()
            self._set_data_by_idx(self._datahandler.get_last_idx() + steps)
            update_nav_buttons(self)

        def refresh(self):
            self.doc.add_next_tick_callback(partial(update_nav_buttons, self))

        def reset_nav_buttons(self):
            btn_nav_prev.disabled = True
            btn_nav_next.disabled = True
            btn_nav_action.label = '❙❙'

        def update_nav_buttons(self):
            last_idx = self._datahandler.get_last_idx()
            last_avail_idx = self._app.get_last_idx(self._figid)

            if last_idx   <   self.lookback:
                btn_nav_prev.disabled = True
                btn_nav_prev_big.disabled = True
            else:
                btn_nav_prev.disabled = False
                btn_nav_prev_big.disabled = False
            if last_idx >= last_avail_idx:
                btn_nav_next.disabled = True
                btn_nav_next_big.disabled = True
            else:
                btn_nav_next.disabled = False
                btn_nav_next_big.disabled = False
            if self._paused:
                btn_nav_action.label = '▶'
            else:
                btn_nav_action.label = '❙❙'

        # filter selection
        datanames = get_datanames(self._strategy)
        options = [('', 'Strategy')]
        for d in datanames:
            options.append(('D' + d, f'Data: {d}'))
        options.append(('G', 'Plot Group'))
        self._filter = 'D' + datanames[0]
        select_filter = Select(
            value=self._filter,
            options=options)
        select_filter.on_change(
            'value',
            partial(on_select_filter, self))
        # nav
        btn_nav_prev = Button(label='❮', width=self.NAV_BUTTON_WIDTH)
        btn_nav_prev.on_click(partial(on_click_nav_prev, self))
        btn_nav_prev_big = Button(label='❮❮', width=self.NAV_BUTTON_WIDTH)
        btn_nav_prev_big.on_click(partial(on_click_nav_prev, self, 10))
        btn_nav_action = Button(label='❙❙', width=self.NAV_BUTTON_WIDTH)
        btn_nav_action.on_click(partial(on_click_nav_action, self))
        btn_nav_next = Button(label='❯', width=self.NAV_BUTTON_WIDTH)
        btn_nav_next.on_click(partial(on_click_nav_next, self))
        btn_nav_next_big = Button(label='❯❯', width=self.NAV_BUTTON_WIDTH)
        btn_nav_next_big.on_click(partial(on_click_nav_next, self, 10))
        # layout
        controls = row(
            children=[select_filter])
        nav = row(
            children=[btn_nav_prev_big,
                      btn_nav_prev,
                      btn_nav_action,
                      btn_nav_next,
                      btn_nav_next_big])
        # tabs
        tabs = Tabs(
            id='tabs',
            sizing_mode=self._app.scheme.plot_sizing_mode)
        # model
        model = layout(
            [
                # app settings, top area
                [column(controls, width_policy='min'),
                 Spacer(),
                 column(nav, width_policy='min')],
                Spacer(height=15),
                # layout for tabs
                [tabs]
            ],
            sizing_mode='stretch_width')
        return model, partial(refresh, self)

    def updatemodel(self):

    def _create_content(self):
        title_area = []
        title = Paragraph(
            text='Available Analyzer Results',
            css_classes=['panel-title'])
        title_area.append(row([title], width_policy='min'))
        if self._client:
            btn_refresh = Button(label='Refresh', width_policy='min')
            btn_refresh.on_click(self._on_update_analyzer_info)
            title_area.append(Spacer())
            title_area.append(row([btn_refresh], width_policy='min'))
        # set content in self
        return layout(
            [
                title_area,
                # initialize with info
                [self._get_analyzer_info()]
            ],
            sizing_mode='stretch_width')

    def _get_panel(self):

    def _create_content(self):
        title_area = []
        title = Paragraph(
            text='Strategy Metadata Overview',
            css_classes=['panel-title'])
        title_area.append(row([title], width_policy='min'))
        if self._client:
            btn_refresh = Button(label='Refresh', width_policy='min')
            btn_refresh.on_click(self._on_update_metadata_info)
            title_area.append(Spacer())
            title_area.append(row([btn_refresh], width_policy='min'))
        # set content in self
        return layout(
            [
                title_area,
                # initialize with info
                [self._get_metadata_info()]
            ],
            sizing_mode='stretch_width')

    def _get_panel(self):

def getNNGrp(uipars=None):
  dict = scikit_dict
  uiobjs = {}
  if not uipars:
    uiobjs = {'nntyp': Select(title='Model', options=getUiNNTypes()),
              'itrparfld': Slider(start=10,end=1000, title='Max Iteration'),
              'lay1parfld': Slider(start=1,end=200, title='Layer 1'),
              'lay2parfld': Slider(start=1,end=50, title='Layer 2'),
              'lay3parfld': Slider(start=1,end=10, title='Layer 3'),
              'lay4parfld': Slider(start=1,end=5, title='Layer 4'),
              'lay5parfld': Slider(start=1,end=3, title='Layer 5'),
              'lrparfld': Slider(start=1,end=100, title='Initial Learning Rate '+ '('+u'\u2030'+')'),
              'addbutton': Button(label='Add',button_type=defaultbut,width=but_width,height=but_height),
              'lessbutton': Button(label='Less',button_type=defaultbut,width=but_width,height=but_height),
              }
    uiobjs['buttonparfld'] = row(uiobjs['addbutton'],Spacer(width = 5),uiobjs['lessbutton'],sizing_mode='stretch_width')
    nb = Slider(start=1,end=5,value=3)
    layergrp = [nb,uiobjs['lay1parfld'],uiobjs['lay2parfld'],uiobjs['lay3parfld'],
                uiobjs['lay4parfld'],uiobjs['lay5parfld'],uiobjs['addbutton'],uiobjs['lessbutton']]
    try:
      uiobjs['lay1parfld'].on_change('value_throttled',partial(layer1ChgCB,layergrp))
      uiobjs['lay2parfld'].on_change('value_throttled',partial(layer2ChgCB,layergrp))
      uiobjs['lay3parfld'].on_change('value_throttled',partial(layer3ChgCB,layergrp))
      uiobjs['lay4parfld'].on_change('value_throttled',partial(layer4ChgCB,layergrp))
    except AttributeError:
      log_msg( '[WARNING] Bokeh version too old, consider updating it.' )
      pass
    uiobjs['addbutton'].on_click(partial(buttonChgCB,uiobjs['addbutton'],layergrp))
    uiobjs['lessbutton'].on_click(partial(buttonChgCB,uiobjs['lessbutton'],layergrp))
    uipars = {'uiobjects': uiobjs,
              'name': regmltypes[2][1],
              'nb': nb
             }
  else:
    uiobjs = uipars['uiobjects']

  uiobjs['nntyp'].value = 'Multi-Layer Perceptron'
  uiobjs['itrparfld'].value = dict['nnpars']['maxitr']
  uiobjs['lay1parfld'].value = 50
  uiobjs['lay2parfld'].value = dict['nnpars']['lay2']
  uiobjs['lay3parfld'].value = dict['nnpars']['lay3']
  uiobjs['lay4parfld'].value = dict['nnpars']['lay4']
  uiobjs['lay5parfld'].value = dict['nnpars']['lay5']
  uiobjs['lrparfld'].value = dict['nnpars']['lr']*1000
  uipars['nb'].value = 3
  return uipars


def getSVMGrp(isclass,uipars=None):

def bkapp(doc):
    global signal
    global ut
    global lt
    global show_segs
    show_segs = False
    ut = 0
    lt = 0
    if signal.any():
        ut = max(signal)
        lt = min(signal)
        source = ColumnDataSource(data={
            'signal'    : signal,
            'position'  : list(range(0,len(signal)))
            })

        p = figure()

        p.line('position','signal', source=source)

        p.add_tools(HoverTool(
            tooltips=[
                ('signal', '@signal'),
                ('position', '@position'),
            ],
            formatters={
                'signal'    : 'printf',
                'position'    : 'printf'
            },
            mode='vline'
        ))

        renderer = p.multi_line([[1,1]], [[1,1]], line_width=4, alpha=0.5, color='green')
        draw_tool = FreehandDrawTool(renderers=[renderer])
        p.add_tools(draw_tool)

        src = ColumnDataSource({
            'x':[1,1,1], 'y':[1,1,1], 'width':[1,1,1], 'height':[1,1,1]
        })
        box_renderer = p.rect('x', 'y', 'width', 'height', fill_alpha=0.4, fill_color='orange', line_color='orange', source=src)
        box_draw_tool = BoxEditTool(renderers=[box_renderer], empty_value=1, num_objects = 5)
        p.add_tools(box_draw_tool)

        ut_slider = Slider(start=lt, end=max(signal), value=max(signal), name='upper_thresh', step=1, title="Upper Threshold")
        lt_slider = Slider(start=min(signal), end=ut, value=min(signal), name='lower_thresh', step=1, title="Lower Threshold")

        def ut_callback(attr, old, new):
            global signal
            global ut
            global lt
            ut = new
            new_signal = scale_outliers(signal, ut, lt)
            source.data = {
                        'signal'    : new_signal,
                        'position'  : list(range(0,len(new_signal)))
                        }
            update_segs()

        def lt_callback(attr, old, new):
            global signal
            global ut
            global lt
            lt = new
            new_signal = scale_outliers(signal, ut, lt)
            source.data = {
                        'signal'    : new_signal,
                        'position'  : list(range(0,len(new_signal)))
                        }
            update_segs()

        ut_slider.on_change('value', ut_callback)
        lt_slider.on_change('value', lt_callback)

        segments = ColumnDataSource(data={
            'top'     : [1,1],
            'bottom'  : [1,1],
            'left'    : [1,1],
            'right'   : [1,1]
            })

        button = Toggle(label="View Segments", sizing_mode="scale_width")

        def segment_handler(new):
            global show_segs
            show_segs = new
            if not new:
                segments.data = {
                    'top'     : [1,1],
                    'bottom'  : [1,1],
                    'left'    : [1,1],
                    'right'   : [1,1]
                            }
            update_segs()

        button.on_click(segment_handler)

        err_slider = Slider(start=0, end=20, value=5, name='error', step=1, title="Allowable Error")
        err_win_slider = Slider(start=0, end=100, value=50, name='err_win', step=1, title="Error Window Size")
        min_win_slider = Slider(start=0, end=500, value=150, name='min_win', step=1, title="Minimum Window Size")
        max_merge_slider = Slider(start=0, end=100, value=50, name='max_merge', step=1, title="Max Merge Distance")
        stdev_scale_slider = Slider(start=0, end=5, value=0.75, name='stdev_scale', step=0.01, title="Standard Deviation Scale Factor")
        stall_len_slider = Slider(start=0, end=5, value=0.25, name='stall_len', step=0.01, title="Stall Length")

        p.quad(top='top',bottom='bottom',left='left',right='right',source=segments,fill_alpha=0.5,fill_color='pink',line_color='pink')

        def err_callback(atrr, old, new):
            global err
            err = new
            update_segs()

        def err_win_callback(atrr, old, new):
            global err_win
            err_win = new
            update_segs()

        def min_win_callback(atrr, old, new):
            global min_win
            min_win = new
            update_segs()

        def max_merge_callback(atrr, old, new):
            global max_merge
            max_merge = new
            update_segs()

        def stdev_scale_callback(atrr, old, new):
            global stdev_scale
            stdev_scale = new
            update_segs()

        def stall_len_callback(atrr, old, new):
            global stall_len
            stall_len = new
            update_segs()

        def update_segs():
            #need to take into account the modified signal- somehow access it?
            global err
            global err_win
            global min_win
            global max_merge
            global stdev_scale
            global stall_len
            global ut
            global lt
            global show_segs
            left = None
            right = None
            if show_segs:
                sig = scale_outliers(signal, ut, lt)
                if sig.any():
                    left, right = get_segs(sig, err, err_win, min_win, max_merge, stdev_scale, stall_len)
                if left is not None and right is not None:
                    segments.data = {
                                'top'     :  np.full(len(left),1000),
                                'bottom'  :  np.full(len(left),0),
                                'left'    :  left,
                                'right'   :  right
                                }
                else:
                    segments.data = {
                        'top'     : [1,1],
                        'bottom'  : [1,1],
                        'left'    : [1,1],
                        'right'   : [1,1]
                                }


        err_slider.on_change('value', err_callback)
        err_win_slider.on_change('value', err_win_callback)
        min_win_slider.on_change('value', min_win_callback)
        max_merge_slider.on_change('value', max_merge_callback)
        stdev_scale_slider.on_change('value', stdev_scale_callback)
        stall_len_slider.on_change('value', stall_len_callback)

        doc.add_root(row(column(Spacer(height=10), ut_slider, lt_slider, Spacer(height=10), button, err_slider, err_win_slider, min_win_slider, max_merge_slider, stdev_scale_slider, stall_len_slider, Spacer(height=10), sizing_mode="stretch_height"), p, sizing_mode="stretch_both"))
        doc.theme = Theme(filename="theme.yaml")

def bk_worker():

def test_grid():
    s0 = Spacer()
    s1 = Spacer()
    s2 = Spacer()
    s3 = Spacer()
    s4 = Spacer()
    s5 = Spacer()
    s6 = Spacer()

    g0 = grid([])
    assert g0.children == []

    g1 = grid(column(s0, row(column(s1, s2, s3, s4, s5), s6)))
    assert g1.children == [
        (s0, 0, 0, 1, 2),
        (s1, 1, 0, 1, 1),
        (s2, 2, 0, 1, 1),
        (s3, 3, 0, 1, 1),
        (s4, 4, 0, 1, 1),
        (s5, 5, 0, 1, 1),
        (s6, 1, 1, 5, 1),
    ]

    g2 = grid([s0, [[s1, s2, s3, s4, s5], s6]])
    assert g2.children == [
        (s0, 0, 0, 1, 2),
        (s1, 1, 0, 1, 1),
        (s2, 2, 0, 1, 1),
        (s3, 3, 0, 1, 1),
        (s4, 4, 0, 1, 1),
        (s5, 5, 0, 1, 1),
        (s6, 1, 1, 5, 1),
    ]

    g3 = grid([s0, s1, s2, s3, s4, s5, s6], ncols=2)
    assert g3.children == [
        (s0, 0, 0, 1, 1),
        (s1, 0, 1, 1, 1),
        (s2, 1, 0, 1, 1),
        (s3, 1, 1, 1, 1),
        (s4, 2, 0, 1, 1),
        (s5, 2, 1, 1, 1),
        (s6, 3, 0, 1, 2),
    ]

    g4 = grid([s0, s1, s2, s3, s4, s5, s6, None], ncols=2)
    assert g4.children == [
        (s0, 0, 0, 1, 1),
        (s1, 0, 1, 1, 1),
        (s2, 1, 0, 1, 1),
        (s3, 1, 1, 1, 1),
        (s4, 2, 0, 1, 1),
        (s5, 2, 1, 1, 1),
        (s6, 3, 0, 1, 1),
    ]

    with pytest.raises(NotImplementedError):
        grid("""
        +----+----+----+----+
        | s1 | s2 | s3 |    |
        +---------+----+ s4 |
        |    s5   | s5 |    |
        +---------+----+----+
        """)

#-----------------------------------------------------------------------------
# Dev API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Private API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Code
#-----------------------------------------------------------------------------