def update_plot(timeRangeStart, timeRangeEnd, timeRangeStartFrame,
timeRangeEndFrame):
# This funtion updates the plot after a change in the time selector widget
#
# @param: timeRangeStart Begin of time range in seconds
# @param: timeRangeEnd End of time range in seconds
# @param: timeRangeStartFrame Begin of time range in frames
# @param: timeRangeEndFrame End of time range in frames
#
timeRangeStartLine.data_source.data['x'] = [
timeRangeStart, timeRangeStart
]
timeRangeEndLine.data_source.data['x'] = [timeRangeEnd, timeRangeEnd]
timeRangeStartFill.data_source.data['x'] = [
0, timeRangeStart, timeRangeStart, 0
]
timeRangeEndFill.data_source.data['x'] = [
timeRangeEnd, dt_snd[-1], dt_snd[-1], timeRangeEnd
]
formantScatterPlot.data_source.data = {
'x': F2[timeRangeStartFrame:timeRangeEndFrame],
'y': F1[timeRangeStartFrame:timeRangeEndFrame]
}
if lineSwitch:
formantLinePlot.data_source.data = {
'x': F2[timeRangeStartFrame:timeRangeEndFrame],
'y': F1[timeRangeStartFrame:timeRangeEndFrame]
}
push_notebook()
def distribution_visualizer(data: dict,
title: str = None,
x_axis: str = None,
y_axis: str = None):
"""
:param data:
:param title:
:param x_axis:
:param y_axis:
"""
entities = list(data.keys())
value = list(data.values())
hover = HoverTool(tooltips=[
("Entities", "@entities"),
("Counts", "$value"),
])
p = figure(x_range=entities,
plot_height=300,
title=title,
toolbar_location='above',
tools=[hover])
p.vbar(x=entities, top=value, width=0.9)
p.xgrid.grid_line_color = None
p.ygrid.grid_line_color = None
t = show(p, notebook_handle=True)
push_notebook(t)
def update_in(x_min=x_min_df, x_interval=default_interval):
nonlocal df1
if df1.index[0] > x_min or df1.index[-1] < x_min + x_interval:
if isinstance(df, pd.DataFrame):
df1 = df[((x_min - max_time / 2) < df.index)
& (df.index < (x_min + max_time / 2))]
else:
df1 = load_continuous_tsd(
df,
t_min=tu.format_timestamps(x_min - max_time / 2,
units=units),
t_max=tu.format_timestamps(x_min + max_time / 2,
units=units),
downsample=downsample).as_units(units)
t = df1.index
with warnings.catch_warnings():
warnings.simplefilter("ignore")
for ix, x in enumerate(df1.columns):
lines[ix].data_source.data['t'] = t
lines[ix].data_source.data[x] = df1[x] + spread_vec[ix]
push_notebook()
plot.x_range.start = x_min
plot.x_range.end = x_min + x_interval
push_notebook()
def update_plot(abs_earliest, abs_latest, abs_num_tasks, tasks):
num_buckets = 100
left, right, top = compute_utilizations(abs_earliest, abs_latest,
abs_num_tasks, tasks,
num_buckets)
time_series_source.data = {
"left": left,
"right": right,
"top": top
}
x_range = (max(0, min(left)) if len(left) else 0,
max(right) if len(right) else 1)
y_range = (0, max(top) + 1 if len(top) else 1)
# Define the axis ranges
x_range = helpers._get_range(x_range)
time_series_fig.x_range.start = x_range.start
time_series_fig.x_range.end = x_range.end
y_range = helpers._get_range(y_range)
time_series_fig.y_range.start = y_range.start
time_series_fig.y_range.end = num_cpus
# Push the updated data to the notebook
push_notebook(handle=handle)
def drawToPlot(self):
fi = self.detector.parameters['freqrange'][0]
ff = self.detector.parameters['freqrange'][1]
self.scorecalculator.SetFreqRange(fi, ff)
x, y, names = self.scorecalculator.GetNoiseCurves()
for i, yi in enumerate(y):
# TODO: fix this, adf 14.02.2018
# the following is a workaround for a Bokeh bug which
# causes lines to not be clipped at the X/Y limits
# See: https://github.com/bokeh/bokeh/issues/6787
yi=np.array(yi)
x=np.array(x)
idxs = np.nonzero((yi<=self.yHi) & (yi>=self.yLo))[0]
if names[i] not in self.names:
self.colours[names[i]] = palettelight[i]
self.lines[names[i]] = self.plot.line(x[idxs], yi[idxs], color=palettelight[i], \
line_width=10)
label = Label(x=x[int(len(x)/2)], y=yi[int(len(yi)/2)],
text=names[i], x_offset=7, y_offset=3, level='glyph', \
render_mode='canvas', text_color=palettelight[i], \
text_font_size='8pt')
self.plot.add_layout(label)
else:
self.lines[names[i]].data_source.data['x'] = x[idxs]
self.lines[names[i]].data_source.data['y'] = yi[idxs]
for nm in self.names:
if nm not in names:
self.lines[nm].data_source.data['x'] = x
self.lines[nm].data_source.data['y'] = [0] * len(x)
self.budget.value = self.budgetMsg()
push_notebook()
def run_clustering(*args):
method = self.w.clu_method.value
stats, trans = run_dr_2()
if method == 'dbscan':
labels = run_dbscan(trans, self.w.clu_dbscan_eps.value)
else:
lg.warning('Not implemented cluster method: {}'.format(method))
return
self.thelenota._CLUSTER_LABELS[self.dr_name()] = labels
colv = labels
color_mapper = CategoricalColorMapper(
palette=bokeh.palettes.Category20[20],
factors=list(colv.value_counts().index))
colorbar_mapper = LinearColorMapper(palette='Inferno256',
low=0,
high=0)
bcolorbar.color_mapper = colorbar_mapper
if not bfigure.legend[0].items:
bfigure.legend[0].items.append(blegend)
bplot.data_source.data['score'] = colv
bplot.glyph.fill_color['transform'] = color_mapper
bplot.glyph.line_width = 0
bplot.glyph.line_alpha = 0
bokeh_io.push_notebook(handle=bhandle)
def plot_line_separate(genfn, source, handle):
"Time a generator while plotting result, using a separate generator for each point"
# Generate first 1000 primes to warm up the code first
list(islice(genfn(approx_nth(1000)), 999, 1000))[0]
for r in range(_repeats):
for n, i in enumerate(iterations()):
def timed():
return list(islice(genfn(approx_nth(i)), i - 1, i))[0]
t = timeit(timed, number=1, globals=globals()) - _overhead
if r == 0:
# First time, stream every measurememt to the plot
source.stream(dict(x=[i], y=[t]))
else:
# Then patch in any lower measurements
if t < source.data['y'][n]:
source.patch(dict(x=[(n, i)], y=[(n, t)]))
if handle:
push_notebook(handle=handle)
if r == 0:
# First time through keep going until just over 1 second elapsed
# with a slight buffer in case following measurements bring it down
if t >= 1.2:
break
else:
# On following passes remeasure each existing point
if n >= len(source.data['x']) - 1:
break
def task_completion_time_update(abs_earliest,
abs_latest,
abs_num_tasks,
tasks):
if len(tasks) == 0:
return
# Create the distribution to plot
distr = []
for task_id, data in tasks.items():
distr.append(data["store_outputs_end"] -
data["get_arguments_start"])
# Create a histogram from the distribution
top, bin_edges = np.histogram(distr, bins="auto")
left = bin_edges[:-1]
right = bin_edges[1:]
source.data = {"top": top, "left": left, "right": right}
# Set the x and y ranges
x_range = (min(left) if len(left) else 0,
max(right) if len(right) else 1)
y_range = (0, max(top) + 1 if len(top) else 1)
x_range = helpers._get_range(x_range)
p.x_range.start = x_range.start
p.x_range.end = x_range.end
y_range = helpers._get_range(y_range)
p.y_range.start = y_range.start
p.y_range.end = y_range.end
# Push updates to the plot
push_notebook(handle=handle)
def _create_scatter_plot(only_color=False):
if (self.w.drfilter_lower_perc_switch.value) or (
self.w.drfilter_log_switch.value):
self.counts = filter_counts()
else:
self.counts = self.thelenota.counttable
self.warn("count table: {}".format(str(self.counts.shape)))
if not only_color:
meta, trans = run_dr_2()
self.thelenota.dr = trans
self.thelenota._dr_meta = meta
self.thelenota._dr_trans = trans
col1, col2 = trans.columns[:2]
d1 = trans[col1]
d2 = trans[col2]
title = self.dr_name().replace('_', ' ')
m = max(d2.max() - d2.min(), d1.max() - d1.min())
bplot.data_source.data['size'] = [0.008 * m] * nosamples
bplot.data_source.data['x'] = d1
bplot.data_source.data['y'] = d2
bfigure.title.text = _create_title()
set_color_scale()
bokeh_io.push_notebook(handle=bhandle)
def _update_plot(self):
self.ds.data['x'] = self.data_frame['iteration']
self.ds.data['y'] = self.data_frame['fitness']
self.ds.data['fill_color'] = self.data_frame['color']
self.ds.data['line_color'] = self.data_frame['color']
self.ds._dirty = True
push_notebook()
def _update(self, ispec=None):
'''Update the data and plots for target number ispec
If ispec is None, use self.ispec; otherwise set self.ispec = ispec
'''
if ispec is not None:
self.ispec = ispec
self._update_data()
if not self._plotted:
return
self._update_xylim()
self._update_lines()
zb = self.zbest[self.izbest]
try:
title = '{0} z={1:.4f} zwarn={2}'.format(zb['SPECTYPE'].strip(),
zb['Z'], zb['ZWARN'])
except KeyError:
title = '{0} ({1}) z={2:.4f} zwarn={3}'.format(
zb['CLASS'].strip(), zb['SUBCLASS'].strip(), zb['Z'],
zb['ZWARNING'])
self.specplot.title.text = title
self._update_info_div()
self._update_cutout()
push_notebook(handle=self.plot_handle)
def notebook_plot(x_key, y_keys, **kwargs):
r"""Live plot log entries in the current notebook.
Parameters
----------
x_key : str
The key in the serialized JSON object that contains the x-axis
value.
y_key : list of str
See `x_key`.
\*\*kwargs
Connection parameters passed to the `connect` function.
"""
subscriber, sequence, x, y = get_socket(x_key, y_keys, **kwargs)
output_notebook()
fig = figure()
plot = fig.line(x, y)
handle = show(fig, notebook_handle=True)
push_notebook(handle=handle)
while True:
update(x_key, y_keys, sequence, subscriber, plot)
push_notebook(handle=handle)
def update_spct(channel=DEFAULT_TICKERS[0], f=10, numbins=20):
channel = int(channel.split('_')[1])
plot_chan = int(channel)
plot_freq = np.where(sc.f_axis == f)[0][0]
y, x = np.histogram(abs(sc.spg[plot_chan, plot_freq, :])**2,
bins=numbins,
density=True)
# create a column data source for the plots to share
data_source = {
'freq_vals': sc.f_axis[1:],
'psd_vals': sc.psd[plot_chan].T[1:],
'scv_vals': sc.scv[plot_chan].T[1:]
}
source.data = data_source
vline_psd.location = f
vline_scv.location = f
# update histogram with data from frequency f
hist_plot.data_source.data['left'] = x[:-1]
hist_plot.data_source.data['right'] = x[1:]
hist_plot.data_source.data['top'] = y
# update fitted
rv = expon(scale=sp.stats.expon.fit(abs(sc.spg[plot_chan,
plot_freq, :])**2,
floc=0)[1])
fit_plot.data_source.data['x'] = x
fit_plot.data_source.data['y'] = rv.pdf(x)
# update complex data
complex_source.data['real_vals'] = sc.spg.real[plot_chan][f]
complex_source.data['imag_vals'] = sc.spg.imag[plot_chan][f]
hist_fig.title.text = 'Freq = %.1fHz, p-value = %.4f' % (
f, sc.ks_pvals[int(plot_chan), f])
push_notebook()
def show_manhattan_plot(df, group_by, x_axis, y_axis):
chroms = df[group_by].unique().to_array()
manhattan_fig = figure()
start_position = -0.5
for chrom in chroms:
query = '%s == %s' % (group_by, chrom)
cdf = df.query(query)
x_array = cupy.fromDlpack(cdf[x_axis].to_dlpack()) + start_position
y_array = cupy.fromDlpack(cdf[y_axis].to_dlpack())
manhattan_fig.circle(x_array.get(),
y_array.get(),
size=2,
color='orange' if
(start_position - 0.5) % 2 == 0 else 'gray',
alpha=0.5)
start_position += 1
manhattan_handle = show(manhattan_fig, notebook_handle=True)
push_notebook(handle=manhattan_handle)
return manhattan_fig
def image_update(Qdata, fig, Nrep, Nplot, stop_flag):
renderer = fig.select(dict(name='echos', type=GlyphRenderer))
source = renderer[0].data_source
img = source.data['image'][0]
while (not stop_flag.is_set()):
new_line = Qdata.get()
#new_line = np.uint8(new_line/np.max(new_line)*255)
if new_line is "EOT":
break
#print(np.percentile(new_line,99))
#print(np.max(new_line))
# Normalize to some percentile instead of max, prevent divide by 0 and apply gamma to help see dim peaks
new_line = np.minimum(
new_line / np.maximum(np.percentile(new_line, 97), 1e-5),
1)**(1 / 1.8)
img = np.roll(img, 1, 0)
view = img.view(dtype=np.uint8).reshape((Nrep, Nplot, 4))
view[0, :, :] = cm.jet(new_line) * 255
source.data['image'] = [img]
push_notebook()
Qdata.queue.clear()
def plot_ssl_wrapper_at_idx(idx):
ssl_wrapper_plotter.plot_ssl_wrapper(wrapper_proto_log[idx])
field_length = wrapper_proto_log[idx].geometry.field.field_length / MM_PER_M
field_width = wrapper_proto_log[idx].geometry.field.field_width / MM_PER_M
the_world = world.World(wrapper_proto_log[idx].SerializeToString(),
dict(friendly_color_yellow=True))
pass_dict = {
"receiver_point": world.Point(-3, 2.5),
"pass_speed": 3,
}
def ratePassEnemyRiskCost(x, y):
pass_dict["passer_point"] = world.Point(x, y)
return passing.ratePassEnemyRisk(the_world, pass_dict, config)
def keepAwayCost(x, y):
pass_dict["passer_point"] = world.Point(x, y)
return keep_away.ratePasserPointForKeepAway(the_world, pass_dict)
enemy_risk_heatmap.plot_heatmap(ratePassEnemyRiskCost)
keep_away_heatmap.plot_heatmap(keepAwayCost)
plotter.plot_points(
[keep_away.findKeepAwayTargetPosition(the_world, pass_dict)])
push_notebook()
def _update_plot(self):
self.ds.data['x'] = self.data_frame['iteration']
self.ds.data['y'] = self.data_frame['fitness']
self.ds.data['fill_color'] = self.data_frame['color']
self.ds.data['line_color'] = self.data_frame['color']
self.ds._dirty = True
push_notebook(handle=self.handle)
def show_candlestick(df, title=None, save=False, width=None, height=None):
is_notebook = in_ipynb()
if is_notebook:
output_notebook()
if width is None:
width = 700 if is_notebook else 1000
if height is None:
height = 350 if is_notebook else 500
inc = df.close > df.open
dec = df.open > df.close
w = 12 * 60 * 60 * 1000 # half day in ms
graph_title = title + ' Chart' if title is not None else 'Chart'
p = figure(x_axis_type="datetime", tools=TOOLS, title=graph_title, plot_width=width, plot_height=height)
p.xaxis.major_label_orientation = pi / 4
p.grid.grid_line_alpha = 0.3
p.xaxis.axis_label = 'Date'
p.yaxis.axis_label = 'Price'
p.segment(df.index, df.high, df.index, df.low, color="black")
p.vbar(df.index[inc], w, df.open[inc], df.close[inc], fill_color='#B2DF8A', line_color="green")
p.vbar(df.index[dec], w, df.open[dec], df.close[dec], fill_color="#FA8072", line_color="red")
if save and not is_notebook:
# Store as a HTML file
output_file("stock_information.html", title="candlestick.py")
# Display
show(p)
if is_notebook:
push_notebook()
def _update_cv_score_std_src(self, cv_score_std):
patches = dict()
for key in cv_score_std.keys():
patches[key] = [(slice(NoteBookVisualizer.stream_rollover * 2),
cv_score_std[key])]
self.cv_score_std_src.patch(patches)
push_notebook(handle=self.bokeh_handle)
def updateInteractive(self, b):
for hisTitle, projectionList in zip(*[iter(self.selectionList)] * 2):
for iDim in range(
self.histArray.FindObject(hisTitle).GetNdimensions() - 1,
-1, -1):
iSlider = self.sliderNames.index(
self.histArray.FindObject(hisTitle).GetAxis(
iDim).GetTitle())
value = self.sliderList[iSlider].value
self.histArray.FindObject(hisTitle).GetAxis(iDim).SetRangeUser(
value[0], value[1])
iterator = 0
for hisTitle, projectionList in zip(*[iter(self.selectionList)] * 2):
dimList = list(map(int, projectionList))
nDim = len(dimList)
if nDim > 1:
raise NotImplementedError(
"Sorry!!.. Multidimensional projections have not been implemented, yet"
)
histogram = self.histArray.FindObject(hisTitle).Projection(
dimList[0])
cds = makeCDS(histogram)
self.source[iterator].data = cds.data
iterator = iterator + 1
push_notebook(self.handle)
def viewCameraStreamJupyterBokeh(self):
try:
# Live view in a Jupyter Notebook
# Flickering occurs
output_notebook()
frame = self.getImage(saveImage=False, saveNumpy=False)
frame = cv2.cvtColor(
frame,
cv2.COLOR_BGR2RGBA) # because Bokeh expects a RGBA image
frame = cv2.flip(frame, -1) # because Bokeh flips vertically
width = frame.shape[1]
height = frame.shape[0]
p = figure(x_range=(0, width),
y_range=(0, height),
width=width,
height=height)
myImage = p.image_rgba(image=[frame],
x=0,
y=0,
dw=width,
dh=height)
show(p, notebook_handle=True)
while True:
frame = self.getImage(saveImage=False, saveNumpy=False)
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA)
frame = cv2.flip(frame, -1)
myImage.data_source.data['image'] = [frame]
push_notebook()
time.sleep(2)
except KeyboardInterrupt:
self.quit_and_open()
def task_completion_time_update(abs_earliest, abs_latest, abs_num_tasks,
tasks):
if len(tasks) == 0:
return
# Create the distribution to plot
distr = []
for task_id, data in tasks.items():
distr.append(data["store_outputs_end"] -
data["get_arguments_start"])
# Create a histogram from the distribution
top, bin_edges = np.histogram(distr, bins="auto")
left = bin_edges[:-1]
right = bin_edges[1:]
source.data = {"top": top, "left": left, "right": right}
# Set the x and y ranges
x_range = (min(left) if len(left) else 0,
max(right) if len(right) else 1)
y_range = (0, max(top) + 1 if len(top) else 1)
x_range = helpers._get_range(x_range)
p.x_range.start = x_range.start
p.x_range.end = x_range.end
y_range = helpers._get_range(y_range)
p.y_range.start = y_range.start
p.y_range.end = y_range.end
# Push updates to the plot
push_notebook(handle=handle)
def update(f, w=1, A=1, phi=0):
"""update"""
if f == 'sin': func = np.sin
elif f == 'cos': func = np.cos
elif f == 'tan': func = np.tan
r.data_source.data['y'] = A * func(w * x + phi)
push_notebook()
def on_sort_change(*args):
order = get_sort_order()
d = bplot.data_source.data
d['x'].index = order
d['y'] = d['y'].loc[order]
d['score'] = d['score'].loc[order]
bokeh_io.push_notebook(handle=bhandle)
def update(bits=3):
# Round to the nearest level based on bits used
levels = 2 ** bits
base = sig.max() / (levels-1)
rounded = base * np.round(sig.y()/base)
digital_signal.update({'y': rounded})
push_notebook(handle=handle)
def update(level):
print("level {}".format(level))
data, title = self[level].plot_data_title(**kwargs)
canvas.title.text = title
source.data = data
push_notebook()
pass
def update(m):
#data = dict(lat=df_bokeh.loc[month_year].latitude,
# lon=df_bokeh.loc[month_year].longitude,
# trap=df_bokeh.loc[month_year].trap,
# species=df_bokeh.loc[month_year].species)
#data1.data = data
r.data_source.data['longitude'] = df_bokeh[df_bokeh.month_year ==
m]['longitude']
r.data_source.data['latitude'] = df_bokeh[df_bokeh.month_year ==
m]['latitude']
r.data_source.data['wnvpresent'] = df_bokeh[df_bokeh.month_year ==
m]['wnvpresent']
r.update
T1 = str(df_bokeh[df_bokeh.month_year == m].month.unique()).replace(
'[', '').replace(']', '')
T2 = str(df_bokeh[df_bokeh.month_year == m].year.unique()).replace(
'[', '').replace(']', '')
p.title.text = "Chicago - West Nile Outbreak - {}/{}".format(T1, T2)
hover = HoverTool(tooltips=[
("Trap", '@trap'),
("Species", '@species'),
("Coordinates", "(@latitude{0.0000}, @longitude{0.0000})"),
])
#p.add_tools(hover)
#hover.update
#print(m)
#p.title.text="Chicago - West Nile Outbreak {}".format
push_notebook()
def display_partial_party_network(plot_data, slice_range_type, slice_range,
slice_changed_callback):
nodes, edges = slice_network_datasource(plot_data.edges, plot_data.nodes,
slice_range, slice_range_type)
plot_data.edges_source.data.update(edges)
plot_data.nodes_source.data.update(nodes)
plot_data.slice_range_type = slice_range_type
plot_data.slice_range = slice_range
sign_dates = plot_data.edges_source.data['signed']
if len(sign_dates) == 0:
return
min_year, max_year = min(sign_dates).year, max(sign_dates).year
slice_changed_callback(min_year, max_year)
print('Slice range by {}: {}-{}, edge count: {} ({})'.format(
'id' if slice_range_type == 1 else 'Year', slice_range[0],
slice_range[1], len(plot_data.edges_source.data['signed']),
len(plot_data.edges['signed'])))
push_notebook(handle=plot_data.handle)
def update(y):
news.set_order_qty(y)
new_sources, new_glyphs = calc_func(news)
for field in sources.keys():
sources[field].data = dict(new_sources[field].data)
if handle is not None:
push_notebook(handle=handle)
def update(f, w=1, A=1, phi=0):
"""update"""
if f == 'sin': func = np.sin
elif f == 'cos': func = np.cos
elif f == 'tan': func = np.tan
r.data_source.data['y'] = A * func(w * x + phi)
push_notebook()
def update_plot(abs_earliest, abs_latest, abs_num_tasks, tasks):
num_buckets = 100
left, right, top = compute_utilizations(abs_earliest,
abs_latest,
abs_num_tasks,
tasks,
num_buckets)
time_series_source.data = {"left": left,
"right": right,
"top": top}
x_range = (max(0, min(left))
if len(left) else 0,
max(right) if len(right) else 1)
y_range = (0, max(top) + 1 if len(top) else 1)
# Define the axis ranges
x_range = helpers._get_range(x_range)
time_series_fig.x_range.start = x_range.start
time_series_fig.x_range.end = x_range.end
y_range = helpers._get_range(y_range)
time_series_fig.y_range.start = y_range.start
time_series_fig.y_range.end = num_cpus
# Push the updated data to the notebook
push_notebook(handle=handle)
def plot_prices(df,
template_name='stock',
notebook=False,
x='Date',
y='Adj. Close',
title="Stock prices",
xlabel="Date",
ylabel="Price"):
"""
Bokeh Plot for stock prices with a custom title and meaningful axis labels.
template_name: output file name of plot
notebook: boolean for showing plot on jupyter notebook
"""
source = ColumnDataSource(df)
# create a new plot with a title and axis labels
p = Figure(
title=title,
x_axis_label=xlabel,
y_axis_label=ylabel,
x_axis_type='datetime',
plot_height=500,
plot_width=950,
tools=['pan', 'wheel_zoom'],
toolbar_location='below',
)
# configure so that Bokeh chooses what (if any) scroll tool is active
p.toolbar.active_scroll = "auto"
# add a line renderer with legend and line thickness
p.line(x=x, y=y, line_width=2, legend='Adj Close', source=source)
p.legend.location = "top_left"
p.legend.click_policy = "hide"
hover = HoverTool(
tooltips=[
('Date', '@Date{%F}'),
('Close',
'$@{Adj. Close}{%0.2f}'), # use @{ } for field names with spaces
('Volume', '@Volume{0.00 a}'),
],
formatters={
'Date': 'datetime', # use 'datetime' formatter for 'date' field
'Adj. Close':
'printf', # use 'printf' formatter for 'adj close' field
# use default 'numeral' formatter for other fields
},
# display a tooltip whenever the cursor is vertically in line with a glyph
mode='vline')
p.add_tools(hover)
if notebook:
# show the results
show(p, notebook_handle=True)
push_notebook()
else:
# output the results
output_file('%s.html' % template_name)
save(p)
def push_data(self):
"""A function to push the content of the source DataFrame
to a specific plot source
"""
self.bokeh_source.data = dict([(x, self.source[x].values) for x in self.source.columns])
self.plot.xaxis.axis_label = self.x_label
self.plot.yaxis.axis_label = self.y_label
push_notebook()
def update(self):
new_data = dict(x=[self.__counter])
for i in range(0, self.__num_lines):
new_data["t00%d" % (i)] = np.array([self.data[i]])
self.__source.stream(new_data, self.resolution)
push_notebook(handle=self.__handle)
self.__counter += 1
self.__line_counter = 0
def slider_value_changed(change):
for cnt1 in range(nimgs):
renderer = fig_t.select(
dict(name='img3d%d' % cnt1, type=GlyphRenderer))
img_t[cnt1].data_source.data['image'] = [
imgs2[cnt1][:, :, sld.value]
]
push_notebook(handle=bk_t)
def generate_table(self, fun):
"""
Generate a table displaying the functions called by fun and their
respective running times. This is done using Bokeh's DataTable widget,
which is based on SlickGrid.
"""
if fun is None:
# Generate summary page
calls = self.cprofile_tree.keys()
else:
calls = [function for function in self.cprofile_tree[fun]['calls']]
self.n_table_elements = len(calls)
names = [call if type(call) == str else call.co_name for call in calls]
# List of tuples containing:
# (id number, name, totaltime, inlinetime, cprofile_key)
calls = list(zip(range(len(calls)), names,
(self.cprofile_tree[x]['totaltime'] for x in calls),
(self.cprofile_tree[x]['inlinetime'] for x in calls),
calls))
self.id_dict = {"function" + str(id): cprofile_key for
(id, name, time, inlinetime, cprofile_key) in calls}
# Sort by total time (descending)
calls.sort(key=lambda x: x[2])
calls.reverse()
# Generate bokeh table
try:
ids, names, times, inlinetimes = list(zip(*calls))[:-1]
except ValueError:
return
time_plot_multiplier = 100 / max(times)
plot_inline_times = [time_plot_multiplier * time for time in
inlinetimes]
plot_extra_times = [time_plot_multiplier * (totaltime - inlinetime)
for totaltime, inlinetime in zip(times,
inlinetimes)]
self.table_data.data = dict(ids=ids, names=names, times=times,
inlinetimes=inlinetimes,
plot_inline_times=plot_inline_times,
plot_extra_times=plot_extra_times)
if self.bokeh_table_div == "":
# First run
self.init_bokeh_table()
else:
if fun is None:
self.bokeh_table.height = 27 + 25 * 20
else:
self.bokeh_table.height = 27 + 25 * min(10, len(calls))
push_notebook()
def push_data(self):
"""A function to push the content of the source DataFrame
to a specific plot source
"""
self.bk_node_source.data = dict([(x, self.node_source[x].values)\
for x in self.node_source.columns])
self.bk_edge_source.data = dict([(x, self.edge_source[x].values)\
for x in self.edge_source.columns])
push_notebook()
def push_data(self):
"""A function to push the content of the source DataFrame
to a specific plot source
"""
self.bokeh_source.data = dict([(x, self.output[x].values) for x in self.output.columns])
self.plot.xaxis.axis_label = self.mapper.x.data_slicer.description
self.plot.yaxis.axis_label = self.mapper.y.data_slicer.description
push_notebook()
def heat_map_update(abs_earliest, abs_latest, abs_num_tasks, tasks):
if len(tasks) == 0:
return
earliest = time.time()
latest = 0
node_to_tasks = dict()
# Determine which task has the earlest start time out of the ones
# passed into the update function
for task_id, data in tasks.items():
if data["score"] > latest:
latest = data["score"]
if data["score"] < earliest:
earliest = data["score"]
worker_id = data["worker_id"]
node_ip = workers[worker_id]["node_ip_address"]
if node_ip not in node_to_tasks:
node_to_tasks[node_ip] = {}
node_to_tasks[node_ip][task_id] = data
nodes = []
times = []
lengths = []
num_tasks = []
for node_ip, task_dict in node_to_tasks.items():
left, right, top = compute_utilizations(earliest,
latest,
abs_num_tasks,
task_dict,
100,
True)
for (l, r, t) in zip(left, right, top):
nodes.append(node_ip)
times.append((l + r) / 2)
lengths.append(r - l)
num_tasks.append(t)
# Set the y range of the plot to be the node IP addresses
p.y_range.factors = list(set(nodes))
mapper.low = min(min(num_tasks), 0)
mapper.high = max(max(num_tasks), 1)
# Update plot with new data based on slider and text box values
source.data = {"node_ip_address": nodes,
"time": times,
"num_tasks": num_tasks,
"length": lengths}
push_notebook(handle=handle)
def update(self, addr, interval):
""" Query the Scheduler, update the figure
This opens a connection to the scheduler, sends it a function to run
periodically, streams the results back and uses those results to update
the bokeh figure
"""
self.stream = yield connect(*addr)
def func(scheduler):
""" Get tasks running or waiting on each worker """
workers = [k for k, v in sorted(scheduler.ncores.items(),
key=lambda x: x[0], reverse=True)]
processing = [list(map(key_split, scheduler.processing[w]))
for w in workers]
nprocessing = list(map(len, processing))
nstacks = [len(scheduler.stacks[w]) for w in workers]
return {'host': [w.split(':')[0] for w in workers],
'processing': processing,
'nprocessing': nprocessing,
'waiting': nstacks}
yield write(self.stream, {'op': 'feed',
'function': dumps(func),
'interval': interval})
while True:
try:
response = yield read(self.stream)
except Exception:
break
self.cds.data.update(response)
n = len(response['host'])
self.figure.y_range.end = max(self.figure.y_range.end,
*response['nprocessing'])
self.figure.extra_y_ranges['waiting'].end = \
max(self.figure.extra_y_ranges['waiting'].end,
*response['waiting'])
self.cds.data['zero'] = [0] * n
self.cds.data['left'] = [i + 0.00 for i in range(n)]
self.cds.data['mid'] = [i + 0.50 for i in range(n)]
self.cds.data['right'] = [i + 1.00 for i in range(n)]
if self.display_notebook:
push_notebook()
def doRender(self, handlerId):
clientHasBokeh = self.options.get("nostore_bokeh", "false") == "true"
if not clientHasBokeh:
output_notebook(hide_banner=True)
data = self.entity.getNextData()
if data is None:
return
x = None
y = None
if isinstance(data, (list,np.ndarray)):
x = list(range(self.windowSize)) if self.glyphRenderer is None else self.glyphRenderer.data_source.data['x']
y = data if self.glyphRenderer is None else self._concatArrays(self.glyphRenderer.data_source.data['y'],data)
if len(y) < self.windowSize:
y = [0]*(self.windowSize-len(y)) + y
elif len(y) > self.windowSize:
y = self._delWindowElements(y)
elif isinstance(data, pandas.core.frame.DataFrame):
pd = pd.drop(pd.index[[0]])
#pd.index = list(range(len(pd.index)))
pd['x'] = list(range(len(pd.index)))
else:
x = data[0]
y = data[1]
if self.glyphRenderer is None:
self.glyphRenderer = self.createGlyphRenderer( self.figure, x, y )
else:
self.updateGlyphRenderer( self.figure, self.glyphRenderer)
if self.glyphRenderer is None:
print("Error: no glyphRenderer found")
return
self.glyphRenderer.data_source.data['x'] = x
self.glyphRenderer.data_source.data['y'] = y
if not self.comms_handle:
state = curstate()
doc = state.document
if self.figure not in doc.roots:
doc.add_root(self.figure)
self.comms_handle = show_doc(self.figure, state, notebook_handle=True)
else:
push_notebook(handle = self.comms_handle)
def update(**kwargs):
lti.update(**kwargs)
g_impulse.data_source.data['x'], g_impulse.data_source.data['y'] = (
impulse(lti.sys, T=t))
g_step.data_source.data['x'], g_step.data_source.data['y'] = (
step(lti.sys, T=t))
g_poles.data_source.data['x'] = lti.sys.poles.real
g_poles.data_source.data['y'] = lti.sys.poles.imag
w, mag, phase, = bode(lti.sys)
g_bode_mag.data_source.data['x'] = w
g_bode_mag.data_source.data['y'] = mag
g_bode_phase.data_source.data['x'] = w
g_bode_phase.data_source.data['y'] = phase
push_notebook()
def push_notebook(self):
""" Update a data source for a plot in a Jupyter notebook.
This function can be be used to update data in plot data sources
in the Jupyter notebook, without having to use the Bokeh server.
.. warning::
This function has been deprecated. Please use
``bokeh.io.push_notebook()`` which will push all changes
(not just data sources) to the last shown plot in a Jupyter
notebook.
Returns:
None
"""
from bokeh.io import push_notebook
push_notebook()
def update(self, addr, interval):
""" Query the Scheduler, update the figure
This opens a connection to the scheduler, sends it a function to run
periodically, streams the results back and uses those results to update
the bokeh figure
"""
self.stream = yield connect(*addr)
def func(scheduler):
""" Get CPU and Memory usage on each worker """
workers = [k for k, v in sorted(scheduler.ncores.items(),
key=lambda x: x[0], reverse=True)]
nannies = [(ip, scheduler.nannies[(ip, port)])
for ip, port in workers]
dicts = [get(-1, scheduler.resource_logs[w], dict())
for w in nannies]
return {'workers': workers,
'cpu': [d.get('cpu_percent', -1) for d in dicts],
'memory': [d.get('memory_percent', -1) for d in dicts]}
yield write(self.stream, {'op': 'feed',
'function': func,
'interval': interval})
while True:
try:
response = yield read(self.stream)
except Exception:
break
self.cds.data['host'] = [host for host, port in response['workers']]
self.cds.data['cpu'] = response['cpu']
self.cds.data['memory'] = response['memory']
n = len(response['workers'])
self.cds.data['zero'] = [0] * n
self.cds.data['left'] = [i + 0.00 for i in range(n)]
self.cds.data['mid'] = [i + 0.50 for i in range(n)]
self.cds.data['right'] = [i + 1.00 for i in range(n)]
if self.display_notebook:
push_notebook()
def update_image(self):
self.logger.debug("redraw surface")
if self.figure is None:
return
# Grab the RGB array for the current image and place it in the
# Bokeh image
data = self.getwin_array(order=self.rgb_order)
ht, wd = data.shape[:2]
# Casting as a 32-bit uint array type hopefully to get more
# efficient JSON encoding en route to the browser
data = data.view(dtype=np.uint32).reshape((ht, wd))
dst_x = dst_y = 0
try:
# Create an Image_RGBA object in the plot
if self.bkimage is None:
self.d_src = ColumnDataSource({'image': [data]})
self.bkimage = self.figure.image_rgba(image='image',
x=dst_x, y=dst_y,
dw=wd, dh=ht,
source=self.d_src)
self._setup_handlers(self.d_src)
else:
# note: get the data source (a ColumnDataSource) and update
# the values
self.logger.info("Updating image")
update = dict(image=[data], x=[dst_x], y=[dst_y],
dw=[wd], dh=[ht])
self.d_src.data = update
if self._push_handle is not None:
self.logger.info("pushing to notebook...")
#self.d_src.push_notebook(self._push_handle)
push_notebook(self._push_handle)
self.logger.info("Image updated")
except Exception as e:
self.logger.error("Error updating image: %s" % (str(e)))
return
def update(self):
""" Query the Scheduler, update the figure
This opens a connection to the scheduler, sends it a function to run
periodically, streams the results back and uses those results to update
the bokeh figure
"""
with log_errors():
tasks, workers = yield [
self.client.fetch('http://%s:%d/tasks.json' % self.addr),
self.client.fetch('http://%s:%d/workers.json' % self.addr)]
tasks = json.loads(tasks.body.decode())
workers = json.loads(workers.body.decode())
task_table_update(self.task_source, tasks)
worker_table_update(self.worker_source, workers)
if self.display_notebook:
push_notebook()
def update_image(self):
if self.figure is None:
return
wd, ht = self.get_window_size()
# Get surface as a numpy array
data = self.renderer.get_surface_as_array(order='RGBA')
# Casting as a 32-bit uint array type hopefully to get more
# efficient JSON encoding en route to the browser
data = data.view(dtype=np.uint32).reshape((ht, wd))
data = np.flipud(data)
dst_x = dst_y = 0
# Create an Image_RGBA object in the plot
if self.bkimage is None:
self.d_src = ColumnDataSource({'image': [data]})
self.bkimage = self.figure.image_rgba(image='image',
x=dst_x, y=dst_y,
dw=wd, dh=ht,
source=self.d_src)
self._setup_handlers(self.d_src)
else:
# note: get the data source (a ColumnDataSource) and update
# the values
self.logger.info("Updating image")
update = dict(image=[data], x=[dst_x], y=[dst_y],
dw=[wd], dh=[ht])
self.d_src.data = update
if self._push_handle is not None:
self.logger.info("pushing to notebook...")
#self.d_src.push_notebook(self._push_handle)
push_notebook(self._push_handle)
self.logger.info("Image updated")
def _throw(self, velocity, v_angle):
assert not self._hit
try:
if self._escaped:
raise UserWarning('%s is not a valid target!' % (self,))
self._update_ball_trajectory(velocity, v_angle)
self._move_target()
distances = cdist(self._ball_path, [[self._mon_x, self._mon_y]])
closest = distances.min()
if closest < self._max_dist:
self._hit = True
impact_point = distances.argmin()
x = self._ball_path[impact_point,0]
y = self._ball_path[impact_point,1]
self._ball_path = self._ball_path[:impact_point]
print('Hit at %0.2f×%0.2f with a distance of %f' % (x, y, closest))
self._interact.widget.set_trait('visible', False)
self._source.data['ball_x'] = self._ball_path[:, 0]
self._source.data['ball_y'] = self._ball_path[:, 1]
# this seems like a filthy hack...
# Bokeh seems to want every data item to have the same len
n = self._source.data['ball_x'].shape[0]
self._source.data['mon_x'] = [self._mon_x]*n
self._source.data['mon_y'] = [self._mon_y]*n
self._source.data['mon_h'] = [self._mon_h]*n
self._source.data['mon_w'] = [self._mon_w]*n
self._source.data['mon_u'] = [self._mon_url]*n
push_notebook()
except UserWarning as e:
print(e)
def push(self):
push_notebook()
def vizpoints(self, x, y):
print(x)
self.p.circle(y, self.dh - np.array(x), fill_color="yellow", size=10)
push_notebook(handle=self.t)
def update(self):
from bokeh.io import push_notebook
self.set_sources()
push_notebook()
def update_notebook_source(source: ColumnDataSource):
if source:
push_notebook()
def notebook_update():
update(x_key, y_key, sequence, subscriber, plot)
push_notebook()
def _update(self):
self.ds.data['x'] = [e[self.x] for e in self.fitness]
self.ds.data['y'] = [e[self.y] for e in self.fitness]
push_notebook(handle=self.handle)
def _update(self):
self.ds.data['x'] = self.iterations[-self.window_size:]
self.ds.data['y'] = self.fitness[-self.window_size:]
push_notebook(handle=self.handle)
