def gen_upd_plot(event): try: ls_tab = [] if inp_gen_upd.label != "Update": cmst_upd = get_dataset() for k in cmst_upd.time_selector: pdf_ts[k] = bmo.ColumnDataSource(data=cmst_upd.get_pandas_df(k)) # Create panel ls_tab.append(create_panel(k)) tabs = bo.layouts.column([ bo.layouts.row([inp_xaxis, inp_yaxis]), bo.layouts.row([bmo.widgets.Tabs(tabs=ls_tab, width=800)]), ]) l.children[-1] = tabs inp_gen_upd.label = "Update" else: cmst_upd = get_dataset() pdf_ts_upd = {} for k in cmst_upd.time_selector: pdf_ts_upd = bmo.ColumnDataSource(data=cmst_upd.get_pandas_df(k)) pdf_ts[k].data.update(pdf_ts_upd.data) dct_buttons[k].callback = bmo.CustomJS(args=dict(source=pdf_ts[k], filename="{}_{}_{}.csv".format(k, inp_time_mean.value, inp_exp.value)), code=open(join(dirname(__file__), "download.js")).read()) hide_spinner() except: div_spinner.text="""
def __init__(self, names, initial_size, width=900, height=480): # Call this once to raise an error early if necessary: self._colors = colors.colors(len(names)) self._start = time.perf_counter() self._initial_size = initial_size self._sources = collections.OrderedDict( [ ( name, { "hist": bm.ColumnDataSource( data={"top": [], "left": [], "right": []} ), "pdf": bm.ColumnDataSource(data={"x": [], "y": []}), "stddev": bm.ColumnDataSource( data={"base": [], "lower": [], "upper": []} ), "median": bm.ColumnDataSource(data={"x": [], "y": []}), }, ) for name in names ] ) self._width = width self._height = height self._plot = None self._elapsed_rendering_seconds = 0.0 self._describe_widget = ipdisplay.HTML("") self._display_id = str(uuid.uuid1())
def create_ColumnDataSource(self): # Get contour paths cdata, ctext = self.get_contours() # Create ColumnDataSource self.ColumnDataSource = bm.ColumnDataSource(cdata) self.ColumnDataSourceText = bm.ColumnDataSource(ctext)
def total_6t(self, match): self.cds_r = bk_models.ColumnDataSource(self.df_new_6t("red", match)) all_teams = list(pd.unique(self.data.schedule.team.sort_values())) self.cds_b = bk_models.ColumnDataSource(self.df_new_6t("blue", match)) r_teams = self.cds_r.column_names[1:4] b_teams = self.cds_b.column_names[1:4] tasks = self.cds_r.data['task'] plt_name = "Six Team Power Cells Placed: Match " + match self.plt_pc = bk_plotting.figure(title=plt_name, x_range=tasks, plot_width=700, plot_height=300, toolbar_location=None, tools="hover", tooltips="$name- @task: @$name") self.plt_pc.vbar_stack(r_teams, x=bk_transform.dodge('task', -0.17, range=self.plt_pc.x_range), width=0.3, source=self.cds_r, legend_label=[" " + x for x in r_teams], color=bk_palettes.Reds3) self.plt_pc.vbar_stack(b_teams, x=bk_transform.dodge('task', 0.17, range=self.plt_pc.x_range), width=0.3, source=self.cds_b, color=bk_palettes.Blues3, legend_label=[" " + x for x in b_teams]) return self.plt_pc
def plot3(model, name, searchfor: str): m1 = model[0] m2 = model[1] if len(model)>2: m3 = model[2] else: m3 = None dfp1 = m1.result_df(searchfor) dfp2 = m2.result_df(searchfor) source1 = bmod.ColumnDataSource(dfp1) source2 = bmod.ColumnDataSource(dfp2) if m3: dfp3 = m3.result_df(searchfor) source3 = bmod.ColumnDataSource(dfp3) #print(dfp1.values.max()) #print(dfp2.values.max()) #print(dfp3.values.max()) if m3: yrange =[0.0, max(dfp1.values.max(), dfp2.values.max(), dfp3.values.max()) ] else: yrange =[0.0, max(dfp1.values.max(), dfp2.values.max()) ] TOOLS = 'pan,box_zoom, box_select,reset' # wheel_zoom, # 545 500 left = bplt.figure(title=name[0], x_axis_label='time', y_axis_label='', y_range=yrange, x_axis_type="datetime", toolbar_location="above", tools=TOOLS, width=545, height=500) for i,col in enumerate(sorted(list(dfp1.columns))): left.line (x="index", y=col, source=source1, legend=" "+col, line_width=2, line_color=COLORS[i], alpha=0.6) middle = bplt.figure(title=name[1], x_axis_label='time', y_axis_label='', y_range=yrange, x_axis_type="datetime", toolbar_location="above", tools=TOOLS, width=545, height=500) for i,col in enumerate(sorted(list(dfp2.columns))): middle.line (x="index", y=col, source=source2, legend=" "+col, line_width=2, line_color=COLORS[i], alpha=0.6) # left.legend.location = "center_right" left.legend.background_fill_alpha = 0.4 # middle.legend.location = "center_right" middle.legend.background_fill_alpha = 0.4 if m3: right = bplt.figure(title=name[2], x_axis_label='time', y_axis_label='', y_range=yrange, x_axis_type="datetime", toolbar_location="above", tools=TOOLS, width=545, height=600) for i,col in enumerate(sorted(list(dfp3.columns))): right.line (x="index", y=col, source=source3, legend=" "+col, line_width=2, line_color=COLORS[i], alpha=0.6) # right.legend.location = "top_left" right.legend.background_fill_alpha = 0.4 if m3: p = bokeh.layouts.gridplot([[left,middle,right]]) else: p = bokeh.layouts.gridplot([[left,middle]]) bokeh.plotting.show(p)
def draw(group): name = group.columns[0][0] color = _colors[name] group.columns = group.columns.droplevel(0) group = group.dropna() quantile_source = bm.ColumnDataSource( pd.DataFrame( data={ "lower": group["25%"], "upper": group["75%"] }, index=group.index, ).dropna().reset_index()) extreme_source = bm.ColumnDataSource( pd.DataFrame( data={ "lower": group["min"], "upper": group["max"] }, index=group.index, ).dropna().reset_index()) plot.line(group.index, group["50%"], line_color=color, legend=name) plot.add_layout( bm.Band( base="time", lower="lower", upper="upper", source=quantile_source, fill_color=color, fill_alpha=0.2, )) plot.add_layout( bm.Band( base="time", lower="lower", upper="upper", source=extreme_source, fill_color=color, fill_alpha=0.025, )) plot.line("time", "lower", line_color=color, alpha=0.5, source=extreme_source) plot.line("time", "upper", line_color=color, alpha=0.5, source=extreme_source)
def __init__(self, readers, rule): self.readers = readers self.rule = rule self.source = bom.ColumnDataSource(self.aligned()) f = bop.figure(x_range=bom.DataRange1d(start=0, follow='end'), tooltips=[('', '$data_y')]) for reader, color in zip(readers, cycle(Category10_10)): p = registry.parse_prefix(reader.prefix) label = dict(legend_label=p.label) if p.label else dict() f.varea(x='_time', y1=f'{reader.prefix}.μ-', y2=f'{reader.prefix}.μ+', color=color, alpha=.2, source=self.source, **label) f.line(x='_time', y=f'{reader.prefix}.μ', color=color, source=self.source, **label) default_tools(f) x_zeroline(f) styling(f) p = registry.parse_prefix(readers[0].prefix) if p.label: legend(f) f.title = bom.Title(text=p.group) self.figure = f
def create_nodes_data_source(network: nx.Graph, layout) -> bm.ColumnDataSource: # pylint: disable=unused-argument nodes, nodes_coordinates = zip(*sorted([x for x in layout.items()])) nodes_xs, nodes_ys = list(zip(*nodes_coordinates)) nodes_source = bm.ColumnDataSource( dict(x=nodes_xs, y=nodes_ys, name=nodes, node_id=nodes)) return nodes_source
def structure_jsmol(cif_str): from jsmol_bokeh_extension import JSMol import bokeh.models as bmd script_source = bmd.ColumnDataSource() info = dict( height="100%", width="100%", use="HTML5", #serverURL="https://chemapps.stolaf.edu/jmol/jsmol/php/jsmol.php", #j2sPath="https://chemapps.stolaf.edu/jmol/jsmol/j2s", serverURL="detail/static/jsmol/php/jsmol.php", j2sPath="detail/static/jsmol/j2s", #serverURL="https://www.materialscloud.org/discover/scripts/external/jsmol/php/jsmol.php", #j2sPath="https://www.materialscloud.org/discover/scripts/external/jsmol/j2s", script=""" set antialiasDisplay ON; load data "cifstring" {} end "cifstring" """.format(cif_str)) applet = JSMol( width=600, height=600, script_source=script_source, info=info, js_url="detail/static/jsmol/JSmol.min.js", ) return applet
def bokeh_brushed(): """these are taken EXACTLY from http://bokeh.pydata.org/en/latest/docs/user_guide/quickstart.html """ # prepare some date N = 300 x = np.linspace(0, 4 * np.pi, N) y0 = np.sin(x) y1 = np.cos(x) # NEW: create a column data source for the plots to share source = bkm.ColumnDataSource(data=dict(x=x, y0=y0, y1=y1)) # create a new plot and add a renderer left = bkp.figure(tools=BOKEH_TOOLS, width=350, height=350, title=None) left.circle('x', 'y0', source=source) # create another new plot and add a renderer right = bkp.figure(tools=BOKEH_TOOLS, width=350, height=350, title=None) right.circle('x', 'y1', source=source) # put the subplots in a gridplot p = bkp.gridplot([[left, right]]) return bke.components(p)
def point_chart(): try: df_temp = rt.ranking_df() df_new = df_temp.filter([ 'avgHatchPoints', 'avgCargoPoints', 'avgClimbPoints', 'avgHabPoints' ], axis=1) points_cds = bmodels.ColumnDataSource(df_new) tm_col_name = points_cds.column_names[0] task = points_cds.column_names[1:] tooltips = [("", "team: @index"), ("", "$name: @$name")] p = plt.figure(title='Points Chart', x_range=points_cds.data[tm_col_name], plot_width=1100, plot_height=350, tooltips=tooltips, toolbar_location="above") hr = p.vbar_stack(task, x=tm_col_name, width=0.4, source=points_cds, color=bpalettes.RdBu4) legend = bokeh.models.Legend(items=[(x, [hr[task.index(x)]]) for x in task], location=(0, 0)) p.add_layout(legend, 'right') p.xaxis.major_label_orientation = 3.14 / 4 return p except Exception: # raise err # print(err) print("The points chart has fallen and cannot get up!")
def draw_tsne(df, fp, alpha=0.69, width=1200, height=1000, show=True, title="Homer Embeddings"): """ draws an interactive plot for data points with auxilirary info on hover """ output_file(fp, title=title) src = bm.ColumnDataSource(df) y = df['y'] mapper = linear_cmap(field_name='y', palette=Category20_9, low=min(y), high=max(y)) fig = pl.figure(active_scroll='wheel_zoom', width=width, height=height, title=title) fig.scatter('x', 'y', size=10, line_color=mapper, color=mapper, fill_alpha=alpha, source=src) fig.add_tools(bm.HoverTool(tooltips=[("token", "@word")])) pl.save(fig, title=title) if show: pl.show(fig)
def plot_list(figure, x_list, y_list, country, RGBs): country = [country] * len(x_list) data = {"year": x_list, "value": y_list, "country": country} source = bkm.ColumnDataSource(data=data) RGB, RGBs = get_random_rgb(RGBs) line = figure.line("year", "value", source=source, color=RGB, alpha=0.5, muted_color=RGB, muted_alpha=0) circle = figure.circle("year", "value", source=source, line_color=RGB, alpha=0.5, fill_color="white", muted_line_color=RGB, muted_fill_color="white", muted_alpha=0) # Done, return return (line, circle, RGBs)
def total_1t(self, team, tasks): self.cds = bk_models.ColumnDataSource(self.df_new_1t(team, tasks)) tasks = self.cds.column_names tasks = tasks[1:] matches = self.cds.data['match'] plt_title = "Team " + team num_tasks = len(tasks) if num_tasks == 0: colors = [] elif num_tasks == 1: colors = ['#5900b3'] elif num_tasks == 2: colors = ['#5900b3', '#e6b800'] else: colors = bk_palettes.Category20[len(tasks)] self.pcplot = bk_plotting.figure(x_range=matches, plot_height=250, title=plt_title, tools="hover", tooltips="$name: @$name") glyphs = self.pcplot.vbar_stack(tasks, x='match', width=0.4, source=self.cds, color=colors) legend_items = [(tasks[i], [glyphs[i]]) for i in range(0, len(tasks), 1)] legend = bk_models.Legend(items=legend_items, location='center') self.pcplot.add_layout(legend, 'right') return self.pcplot
def __init__(self): self.inp_cif = pn.widgets.FileInput(name='CIF', accept='.cif') self.btn_cif = pn.widgets.Button(name='Parse CIF', button_type='primary') self.btn_cif.on_click(self.on_click_parse) self.ckbox_2x = pn.widgets.Checkbox(name='Force to replicate 2x in C direction') self.ckbox_relabel_cab = pn.widgets.Checkbox(name='Relabel cell vectors abc to cab') self.ckbox_relabel_bca = pn.widgets.Checkbox(name='Relabel cell vectors abc to bca') from structure import structure_jsmol import bokeh.models as bmd self.jsmol_script_source = bmd.ColumnDataSource() self.applet = structure_jsmol(self.jsmol_script_source) self.inp_source = pn.widgets.Select(name='CIF source', options={'SI': 'SI', 'SI (CIF)': 'SI (CIF)', 'CSD': 'CSD', 'Private Communication': "Priv. Comm."}) self.inp_csd = pn.widgets.TextInput(name='CSD Number', placeholder='1846139') self.inp_name = pn.widgets.TextInput(name='CIF name', placeholder='As used in publication') self.inp_dimensionality = pn.widgets.TextInput(name='CIF dimensionality', placeholder='Detected by ASE') self.inp_elements = pn.widgets.TextInput(name='CIF elements', placeholder='C,H,...') self.inp_modifications = pn.widgets.AutocompleteInput( name='CIF modifications', value='none', options=list(set(get_frameworks_df()['Modifications'])), restrict=False) self.inp_charge = pn.widgets.Select(name='CIF charge', options={ 'Neutral': 'N', 'Charged': 'C' }) self.inp_cof_id = pn.widgets.TextInput(name='COF ID', value='none') self.btn_mint_id = pn.widgets.Button(name='Mint', button_type='primary') self.btn_mint_id.on_click(self.mint_framework_id) self.btn_add_cif = pn.widgets.Button(name='Add CIF', button_type='primary') self.btn_add_cif.on_click(self.on_click_add)
def plotAVO(tools, model): ''' Creates an AVO Intercept and Gradient Plot from a model. ''' #AVO PLOT TYPES bkplot = bkp.figure(tools=tools, title='AVO Intercept vs Gradient', y_range=[-0.5, 0.5], x_range=[-0.5, 0.5], x_axis_label='Intercept', y_axis_label='Gradient') # iterate over each interface in the model for intf in model: source = bkm.ColumnDataSource( data=dict(A=intf.AVOMod[:, 6], B=intf.AVOMod[:, 7])) bkplot.circle('A', 'B', color=intf.colour, legend=intf.name, source=source, size=5) bkplot.legend.location = 'top_right' plotOpt(bkplot) return bkplot
def __init__(self, readers, rule): [self.reader] = readers self.rule = rule aligned = self.aligned() self.source = bom.ColumnDataSource(aligned) f = bop.figure(x_range=bom.DataRange1d(start=0, follow='end', range_padding=0), y_range=bom.DataRange1d(start=0), tooltips=[('', '$data_y')]) p = registry.parse_prefix(self.reader.prefix) n_bands = aligned.shape[1] - 1 assert n_bands % 2 == 1 for i in range(n_bands): color = Viridis256[255 - 256 * i // n_bands] lower = aligned.columns[i + 1] f.line(x='_time', y=f'{lower}', color=color, source=self.source) default_tools(f) styling(f) p = registry.parse_prefix(readers[0].prefix) f.title = bom.Title(text=p.group) self.figure = f
def get_edges_source(network, layout, scale=1.0, normalize=False): _, _, weights, xs, ys = NetworkUtility.get_edge_layout_data(network, layout) norm = max(weights) if normalize else 1.0 weights = [ scale * x / norm for x in weights ] lines_source = bm.ColumnDataSource(dict(xs=xs, ys=ys, weights=weights)) return lines_source
def __init__(self, readers, **kwargs): self.readers = readers self.source = bom.ColumnDataSource(self.combined()) f = bop.figure(tooltips=[('', '$data_y')]) for reader, color in zip(readers, cycle(Category10_10)): p = registry.parse_prefix(reader.prefix) label = dict(legend_label=p.label) if p.label else dict() f.line(x=f'{reader.prefix}.x', y=f'{reader.prefix}.y', color=color, source=self.source, **label) f.circle(x=f'{reader.prefix}.x', y=f'{reader.prefix}.y', color=color, source=self.source, **label) f.title = bom.Title(text=p.group) default_tools(f) self.figure = f
def total_pt(self): df_temp = self.df df_new = df_temp.filter([ 'avg_autoOuterPoints', 'avg_autoInnerPoints', 'avg_teleInnerPoints', 'avg_teleLowerPoints', 'avg_teleOuterPoints', 'avg_climbpoints', 'avg_parkpoints' ], axis=1) points_cds = bmodels.ColumnDataSource(df_new) tm_col_name = points_cds.column_names[0] task = points_cds.column_names[1:] tooltips = [("", "team: @team"), ("", "$name: @$name")] p = plt.figure(title='Points Chart', x_range=points_cds.data[tm_col_name], plot_width=1100, plot_height=350, tooltips=tooltips, toolbar_location="above") hr = p.vbar_stack(task, x=tm_col_name, width=0.5, source=points_cds, color=bpalettes.Category10[7]) legend = bokeh.models.Legend(items=[(x, [hr[task.index(x)]]) for x in task], location=(0, 0)) p.add_layout(legend, 'right') p.xaxis.major_label_orientation = 3.14 / 4 self.chart = p return self.chart
def structure_jsmol(cif_node): script_source = bmd.ColumnDataSource() cif_str = cif_node.get_content() info = dict( height="100%", width="100%", use="HTML5", #serverURL="https://chemapps.stolaf.edu/jmol/jsmol/php/jsmol.php", #j2sPath="https://chemapps.stolaf.edu/jmol/jsmol/j2s", serverURL="detail_pyrenemofs/static/jsmol/php/jsmol.php", j2sPath="detail_pyrenemofs/static/jsmol/j2s", script=""" set antialiasDisplay ON; load data "cifstring" {} end "cifstring" """.format(cif_str)) applet = JSMol( width=600, height=600, script_source=script_source, info=info, js_url="detail_pyrenemofs/static/jsmol/JSmol.min.js", ) return applet
def __init__(self, run_name=-1, prefix=''): super().__init__() self._reader = stats.Reader(run_name, prefix) self._source = bom.ColumnDataSource({'time': np.array([0])}) self._handle = None
def create_edges_layout_data_source( network: nx.Graph, layout: NodesLayout, scale: float = 1.0, normalize: bool = False, weight: str = 'weight', project_range: Tuple[float, float] = None, discrete_divisor=None, ) -> bm.ColumnDataSource: _, _, weights, xs, ys = layout_edges(network, layout, weight=weight) if isinstance(discrete_divisor, int): weights = [max(1, x // discrete_divisor) for x in weights] # elif project_range is not None: # # same as _project_series_to_range # w_max = max(weights) # low, high = project_range # weights = [ low + (high - low) * (x / w_max) for x in weights ] elif project_range is not None: # same as _project_series_to_range w_max = max(weights) low, high = project_range weights = [int(round(max(low, high * (x / w_max)))) for x in weights] else: norm = max(weights) if normalize else 1.0 weights = [scale * x / norm for x in weights] lines_source = bm.ColumnDataSource(dict(xs=xs, ys=ys, weights=weights)) return lines_source
def plot_steps(out_dict, units): """ Plot convergence steps in Bokeh """ from bokeh.models import BoxAnnotation from bokeh.plotting import figure, show, output_notebook import bokeh.models as bmd tooltips = [("Step (total)", "@index"), ("Step (stage)", "@step"), ("Energy", "@energy eV/atom"), ("Energy (dispersion)", "@dispersion_energy_au Ha"), ("SCF converged", "@scf_converged"), ("Cell A", "@cell_a_angs Angs"), ("Cell Vol", "@cell_vol_angs3 Angs^3"), ("MAX Step", "@max_step_au Bohr"), ("Pressure", "@pressure_bar bar")] hover = bmd.HoverTool(tooltips=tooltips) TOOLS = ["pan", "wheel_zoom", "box_zoom", "reset", "save", hover] natoms = out_dict['natoms'] values = [ x / natoms * ha2u[units] for x in out_dict['step_info']['energy_au'] ] values = [x - min(values) for x in values] data = bmd.ColumnDataSource(data=dict( index=range(len(values)), step=out_dict['step_info']['step'], energy=values, dispersion_energy_au=out_dict['step_info']['dispersion_energy_au'], scf_converged=out_dict['step_info']['scf_converged'], cell_a_angs=out_dict['step_info']['cell_a_angs'], cell_vol_angs3=out_dict['step_info']['cell_vol_angs3'], max_step_au=out_dict['step_info']['max_step_au'], pressure_bar=out_dict['step_info']['pressure_bar'], )) p = figure(tools=TOOLS, title='Energy profile of the DFT minimization', height=350, width=550) p.xgrid.grid_line_color = None p.xaxis.axis_label = 'Steps' p.yaxis.axis_label = 'Energy ({}/atom)'.format(units) # Colored background colors = ['red', 'orange', 'green', 'yellow', 'cyan', 'pink', 'palegreen'] start = 0 for i, steps in enumerate(out_dict['stage_info']['nsteps']): end = start + steps p.add_layout( BoxAnnotation(left=start, right=end, fill_alpha=0.2, fill_color=colors[i])) start = end # Trace line and markers p.line('index', 'energy', source=data, line_color='blue') p.circle('index', 'energy', source=data, line_color='blue', size=3) return p
def get_seasonal_source(dataframes: dict) -> dict: """ Get the seasonal data sources Args: dataframes: the data Returns: bokeh data sources """ data_sources = {} for label, data_table in dataframes.items(): table_sources = {} for table_name, data_columns in data_table.items(): columns_sources = {} for column_name, data_column in data_columns.items(): column_sources = {} for frequency, freq_data in data_column.items(): freq_sources = {} for name, data_source in freq_data.items(): freq_sources[name] = \ mdl.ColumnDataSource(data_source) column_sources[frequency] = freq_sources columns_sources[column_name] = column_sources table_sources[table_name] = columns_sources data_sources[label] = table_sources return data_sources
def draw_vectors(x, y, radius=10, alpha=0.25, color='blue', width=600, height=400, show=True, **kwargs): """ draws an interactive plot for data points with auxilirary info on hover """ if isinstance(color, str): color = [color] * len(x) data_source = bm.ColumnDataSource({ 'x': x, 'y': y, 'color': color, **kwargs }) fig = pl.figure(active_scroll='wheel_zoom', width=width, height=height) fig.scatter('x', 'y', size=radius, color='color', alpha=alpha, source=data_source) fig.add_tools( bm.HoverTool(tooltips=[(key, "@" + key) for key in kwargs.keys()])) if show: pl.show(fig) return fig
def make_map_source(self, df=None): import bokeh.models as bm # Test if there exists data if type(df) != type(None): # Make copy of dict kdic = self.kdic.copy() # Collect stemme_pct_list = [] # Loop through dic for i, kommune in enumerate(kdic['kommuner']): #kommune_date = kdic['kommuner_dates'][i] #print(kommune.replace("Aa", "Å")) if kommune in df['Kommune'].values: stemme_pct = df.loc[df['Kommune'] == kommune, 'stemme_pct'].iloc[0] stemme_pct_list.append(stemme_pct) # If s is added elif kommune[:-1] in df['Kommune'].values: stemme_pct = df.loc[df['Kommune'] == kommune[:-1], 'stemme_pct'].iloc[0] stemme_pct_list.append(stemme_pct) elif kommune + "s" in df['Kommune'].values: stemme_pct = df.loc[df['Kommune'] == kommune + "s", 'stemme_pct'].iloc[0] stemme_pct_list.append(stemme_pct) elif kommune.replace("Å", "Aa").replace("å", "aa").replace( "Høje Taastrup", "Høje-Taastrup") in df['Kommune'].values: stemme_pct = df.loc[ df['Kommune'] == kommune.replace("Å", "Aa").replace("å", "aa"). replace("Høje Taastrup", "Høje-Taastrup"), 'stemme_pct'].iloc[0] stemme_pct_list.append(stemme_pct) else: #print(kommune, "Not found") stemme_pct_list.append(None) # append kdic['stemme_pct'] = stemme_pct_list # Create data self.source = bm.ColumnDataSource(data=kdic) else: print("Making source from map") self.source = bm.ColumnDataSource(data=self.kdic)
def create_nodes_data_source(network, layout): nodes, nodes_coordinates = zip(*sorted([x for x in layout.items() ])) # if x[0] in line_nodes])) nodes_xs, nodes_ys = list(zip(*nodes_coordinates)) nodes_source = bm.ColumnDataSource( dict(x=nodes_xs, y=nodes_ys, name=nodes, node_id=nodes)) return nodes_source
def source_for_param_space(param_space): source = bm.ColumnDataSource( pd.DataFrame({ 'tstamp': [], 'cummax_score': [], 'mean_test_score': [], 'params': np.array([], dtype=str), })) return source
def get_node_subset_source(network, layout, node_list = None): layout_items = layout.items() if node_list is None else [ x for x in layout.items() if x[0] in node_list ] nodes, nodes_coordinates = zip(*sorted(layout_items)) xs, ys = list(zip(*nodes_coordinates)) nodes_source = bm.ColumnDataSource(dict(x=xs, y=ys, name=nodes, node_id=nodes)) return nodes_source