def test_dynamic_stream_transients(self):
# Ensure Stream reset option resets streams to default value
# when not triggering
global xresets, yresets
xresets, yresets = 0, 0
def history_callback(x, y, history=deque(maxlen=10)):
global xresets, yresets
if x is None:
xresets += 1
else:
history.append(x)
if y is None:
yresets += 1
return Curve(list(history))
x = PointerX(transient=True)
y = PointerY(transient=True)
dmap = DynamicMap(history_callback, kdims=[], streams=[x, y])
# Add stream subscriber mocking plot
x.add_subscriber(lambda **kwargs: dmap[()])
y.add_subscriber(lambda **kwargs: dmap[()])
# Update each stream and count when None default appears
for i in range(2):
x.event(x=i)
y.event(y=i)
self.assertEqual(xresets, 2)
self.assertEqual(yresets, 2)
def test_subscriber_clear_internal(self):
pointerx = PointerX(x=2)
pointerx.add_subscriber(self.fn1, precedence=0)
pointerx.add_subscriber(self.fn2, precedence=1)
pointerx.add_subscriber(self.fn3, precedence=1.5)
pointerx.add_subscriber(self.fn4, precedence=10)
self.assertEqual(pointerx.subscribers, [self.fn1,self.fn2,self.fn3,self.fn4])
pointerx.clear('internal')
self.assertEqual(pointerx.subscribers, [self.fn1,self.fn2])
def test_subscriber_clear_internal(self):
pointerx = PointerX(x=2)
pointerx.add_subscriber(self.fn1, precedence=0)
pointerx.add_subscriber(self.fn2, precedence=1)
pointerx.add_subscriber(self.fn3, precedence=1.5)
pointerx.add_subscriber(self.fn4, precedence=10)
self.assertEqual(pointerx.subscribers, [self.fn1,self.fn2,self.fn3,self.fn4])
pointerx.clear('internal')
self.assertEqual(pointerx.subscribers, [self.fn1,self.fn2])
def test_stream_callback_single_call(self):
def history_callback(x, history=deque(maxlen=10)):
history.append(x)
return Curve(list(history))
stream = PointerX(x=0)
dmap = DynamicMap(history_callback, kdims=[], streams=[stream])
plot = plotly_renderer.get_plot(dmap)
plotly_renderer(dmap)
for i in range(20):
stream.event(x=i)
state = plot.state
self.assertEqual(state['data'][0]['x'], np.arange(10))
self.assertEqual(state['data'][0]['y'], np.arange(10, 20))
def test_stream_callback_single_call(self):
def history_callback(x, history=deque(maxlen=10)):
history.append(x)
return Curve(list(history))
stream = PointerX(x=0)
dmap = DynamicMap(history_callback, kdims=[], streams=[stream])
plot = plotly_renderer.get_plot(dmap)
plotly_renderer(plot)
for i in range(20):
stream.event(x=i)
state = plot.state
self.assertEqual(state['data'][0]['x'], np.arange(10))
self.assertEqual(state['data'][0]['y'], np.arange(10, 20))
def test_stream_callback_single_call(self):
def history_callback(x, history=deque(maxlen=10)):
history.append(x)
return Curve(list(history))
stream = PointerX(x=0)
dmap = DynamicMap(history_callback, kdims=[], streams=[stream])
plot = bokeh_server_renderer.get_plot(dmap)
bokeh_server_renderer(plot)
for i in range(20):
stream.event(x=i)
data = plot.handles['source'].data
self.assertEqual(data['x'], np.arange(10))
self.assertEqual(data['y'], np.arange(10, 20))
def test_stream_callback_single_call(self):
def history_callback(x, history=deque(maxlen=10)):
history.append(x)
return Curve(list(history))
stream = PointerX(x=0)
dmap = DynamicMap(history_callback, kdims=[], streams=[stream])
plot = bokeh_server_renderer.get_plot(dmap)
bokeh_server_renderer(plot)
for i in range(20):
stream.event(x=i)
data = plot.handles['source'].data
self.assertEqual(data['x'], np.arange(10))
self.assertEqual(data['y'], np.arange(10, 20))
def test_stream_callback_single_call(self):
def history_callback(x, history=deque(maxlen=10)):
history.append(x)
return Curve(list(history))
stream = PointerX(x=0)
dmap = DynamicMap(history_callback, kdims=[], streams=[stream])
plot = mpl_renderer.get_plot(dmap)
mpl_renderer(plot)
for i in range(20):
plot.state.set_dpi(72)
stream.event(x=i)
x, y = plot.handles['artist'].get_data()
self.assertEqual(x, np.arange(10))
self.assertEqual(y, np.arange(10, 20))
def test_stream_callback_single_call(self):
def history_callback(x, history=deque(maxlen=10)):
history.append(x)
return Curve(list(history))
stream = PointerX(x=0)
dmap = DynamicMap(history_callback, kdims=[], streams=[stream])
plot = mpl_renderer.get_plot(dmap)
mpl_renderer(plot)
for i in range(20):
plot.state.set_dpi(72)
stream.event(x=i)
x, y = plot.handles['artist'].get_data()
self.assertEqual(x, np.arange(10))
self.assertEqual(y, np.arange(10, 20))
def test_callback_cleanup(self):
stream = PointerX(x=0)
dmap = DynamicMap(lambda x: Curve([x]), streams=[stream])
plot = bokeh_server_renderer.get_plot(dmap)
self.assertTrue(bool(stream._subscribers))
self.assertTrue(bool(Callback._callbacks))
plot.cleanup()
self.assertFalse(bool(stream._subscribers))
self.assertFalse(bool(Callback._callbacks))
def test_batched_curve_subscribers_correctly_attached(self):
posx = PointerX()
opts = {'NdOverlay': dict(plot=dict(legend_limit=0)),
'Curve': dict(style=dict(line_color=Cycle(values=['red', 'blue'])))}
overlay = DynamicMap(lambda x: NdOverlay({i: Curve([(i, j) for j in range(2)])
for i in range(2)}).opts(opts), kdims=[],
streams=[posx])
plot = bokeh_renderer.get_plot(overlay)
self.assertIn(plot.refresh, posx.subscribers)
self.assertNotIn(list(plot.subplots.values())[0].refresh, posx.subscribers)
def test_pointer_x_datetime_out_of_bounds(self):
points = Points([(dt.datetime(2017, 1, 1), 1), (dt.datetime(2017, 1, 3), 3)])
PointerX(source=points)
plot = bokeh_server_renderer.get_plot(points)
callback = plot.callbacks[0]
self.assertIsInstance(callback, PointerXCallback)
msg = callback._process_msg({'x': 1000})
self.assertEqual(msg['x'], np.datetime64(dt.datetime(2017, 1, 1)))
msg = callback._process_msg({'x': 10000000000000})
self.assertEqual(msg['x'], np.datetime64(dt.datetime(2017, 1, 3)))
def test_dynamic_stream_transients(self):
# Ensure Stream reset option resets streams to default value
# when not triggering
global xresets, yresets
xresets, yresets = 0, 0
def history_callback(x, y, history=deque(maxlen=10)):
global xresets, yresets
if x is None:
xresets += 1
else:
history.append(x)
if y is None:
yresets += 1
return Curve(list(history))
x = PointerX(transient=True)
y = PointerY(transient=True)
dmap = DynamicMap(history_callback, kdims=[], streams=[x, y])
# Add stream subscriber mocking plot
x.add_subscriber(lambda **kwargs: dmap[()])
y.add_subscriber(lambda **kwargs: dmap[()])
# Update each stream and count when None default appears
for i in range(2):
x.event(x=i)
y.event(y=i)
self.assertEqual(xresets, 2)
self.assertEqual(yresets, 2)
def test_batched_curve_subscribers_correctly_linked(self):
# Checks if a stream callback is created to link batched plot
# to the stream
posx = PointerX()
opts = {'NdOverlay': dict(plot=dict(legend_limit=0)),
'Curve': dict(style=dict(line_color=Cycle(values=['red', 'blue'])))}
overlay = DynamicMap(lambda x: NdOverlay({i: Curve([(i, j) for j in range(2)])
for i in range(2)}).opts(opts), kdims=[],
streams=[posx])
plot = bokeh_renderer.get_plot(overlay)
self.assertEqual(len(Callback._callbacks), 1)
key = list(Callback._callbacks.keys())[0]
self.assertEqual(key, (id(plot.handles['plot']), id(PointerXCallback)))
def view(self, cmap=None, shade=True):
raster_opts = dict(aggregator=self.aggregator, precompute=True)
cmap_opts = dict(cmap=cmap) if cmap else {}
if shade:
if cmap: raster_opts.update(cmap_opts)
shaded = datashade(self.obj, **raster_opts)
else:
shaded = rasterize(self.obj, **raster_opts).opts(style=cmap_opts)
point_x = PointerX(source=self.sections, x=0)
vline = DynamicMap(VLine, streams=[point_x])
points = Dynamic(self.sections,
operation=self._pos_indicator,
streams=[point_x])
return (self.tiles * shaded * self.path * points +
self.sections * vline)
def test_dynamic_callable_disable_callable_memoize(self):
# Disabling Callable.memoize means no memoization is applied,
# every access to DynamicMap calls callback and adds sample
def history_callback(x, history=deque(maxlen=10)):
history.append(x)
return Curve(list(history))
x = PointerX()
callable_obj = Callable(history_callback, memoize=False)
dmap = DynamicMap(callable_obj, kdims=[], streams=[x])
# Add stream subscriber mocking plot
x.add_subscriber(lambda **kwargs: dmap[()])
for i in range(2):
x.event(x=1)
self.assertEqual(dmap[()], Curve([1, 1, 1]))
for i in range(2):
x.event(x=2)
self.assertEqual(dmap[()], Curve([1, 1, 1, 2, 2, 2]))
def test_dynamic_callable_memoize(self):
# Always memoized only one of each held
def history_callback(x, history=deque(maxlen=10)):
history.append(x)
return Curve(list(history))
x = PointerX()
dmap = DynamicMap(history_callback, kdims=[], streams=[x])
# Add stream subscriber mocking plot
x.add_subscriber(lambda **kwargs: dmap[()])
for i in range(2):
x.event(x=1)
self.assertEqual(dmap[()], Curve([1]))
for i in range(2):
x.event(x=2)
self.assertEqual(dmap[()], Curve([1, 2]))
def test_dynamic_compute_overlayable_zorders_mixed_dynamic_and_dynamic_ndoverlay_with_streams_cloned(self):
ndoverlay = DynamicMap(lambda x: NdOverlay({i: Area(range(10+i)) for i in range(2)}),
kdims=[], streams=[PointerX()])
curve = DynamicMap(lambda: Curve(range(10)), kdims=[])
curve_redim = curve.redim(x='x2')
combined = ndoverlay*curve_redim
combined[()]
sources = compute_overlayable_zorders(combined.clone())
self.assertIn(ndoverlay, sources[0])
self.assertNotIn(curve_redim, sources[0])
self.assertNotIn(curve, sources[0])
self.assertIn(ndoverlay, sources[1])
self.assertNotIn(curve_redim, sources[1])
self.assertNotIn(curve, sources[1])
self.assertIn(curve_redim, sources[2])
self.assertIn(curve, sources[2])
self.assertNotIn(ndoverlay, sources[2])
def test_dynamic_callable_stream_transient(self):
# Enable transient stream meaning memoization only happens when
# stream is inactive, should have sample for each call to
# stream.update
def history_callback(x, history=deque(maxlen=10)):
if x is not None:
history.append(x)
return Curve(list(history))
x = PointerX(transient=True)
dmap = DynamicMap(history_callback, kdims=[], streams=[x])
# Add stream subscriber mocking plot
x.add_subscriber(lambda **kwargs: dmap[()])
for i in range(2):
x.event(x=1)
self.assertEqual(dmap[()], Curve([1, 1]))
for i in range(2):
x.event(x=2)
self.assertEqual(dmap[()], Curve([1, 1, 2, 2]))
def test_dynamic_callable_disable_callable_memoize(self):
# Disabling Callable.memoize means no memoization is applied,
# every access to DynamicMap calls callback and adds sample
def history_callback(x, history=deque(maxlen=10)):
history.append(x)
return Curve(list(history))
x = PointerX()
callable_obj = Callable(history_callback, memoize=False)
dmap = DynamicMap(callable_obj, kdims=[], streams=[x])
# Add stream subscriber mocking plot
x.add_subscriber(lambda **kwargs: dmap[()])
for i in range(2):
x.event(x=1)
self.assertEqual(dmap[()], Curve([1, 1, 1]))
for i in range(2):
x.event(x=2)
self.assertEqual(dmap[()], Curve([1, 1, 1, 2, 2, 2]))
def test_dynamic_callable_memoize(self):
# Always memoized only one of each held
def history_callback(x, history=deque(maxlen=10)):
history.append(x)
return Curve(list(history))
x = PointerX()
dmap = DynamicMap(history_callback, kdims=[], streams=[x])
# Add stream subscriber mocking plot
x.add_subscriber(lambda **kwargs: dmap[()])
for i in range(2):
x.event(x=1)
self.assertEqual(dmap[()], Curve([1]))
for i in range(2):
x.event(x=2)
self.assertEqual(dmap[()], Curve([1, 2]))
def test_dynamic_callable_stream_transient(self):
# Enable transient stream meaning memoization only happens when
# stream is inactive, should have sample for each call to
# stream.update
def history_callback(x, history=deque(maxlen=10)):
if x is not None:
history.append(x)
return Curve(list(history))
x = PointerX(transient=True)
dmap = DynamicMap(history_callback, kdims=[], streams=[x])
# Add stream subscriber mocking plot
x.add_subscriber(lambda **kwargs: dmap[()])
for i in range(2):
x.event(x=1)
self.assertEqual(dmap[()], Curve([1, 1]))
for i in range(2):
x.event(x=2)
self.assertEqual(dmap[()], Curve([1, 1, 2, 2]))
def test_simple_constructor_streams_dict(self):
pointerx = PointerX()
DynamicMap(lambda x: x, streams=dict(x=pointerx.param.x))
def setUp(self):
self.dimstream = PointerX(x=0)
self.stream = PointerY(y=0)
self.dmap = DynamicMap(lambda x, y, z: Curve([x, y, z]),
kdims=['x', 'z'],
streams=[self.stream, self.dimstream])
def test_simple_constructor_streams(self):
DynamicMap(lambda x: x, streams=[PointerX()])
def build_map_pane(self):
if self.adh_mod.mesh.verts.empty:
self.map_pane = self.adh_mod.map_view
self.analysis_pane = pn.Spacer()
else:
# create the meshes for the dynamic map
meshes = self.create_animation()
edgepaths_overlay = self.adh_mod.mesh.view_elements()
# Define dynamic options
opts = dict(clipping_colors={
'NaN': 'transparent',
'min': 'transparent'
},
cmap=self.cmap_opts.param.colormap,
clim=self.display_range.param.color_range,
height=600,
width=600)
if meshes.label == 'scalar':
# todo THIS IS GOING TO LOSE ALL ANNOTATIONS EVERY TIME THE MAP IS REDRAWN
rasterized = rasterize(meshes).apply.opts(**opts)
# Apply the colormap and color range dynamically
dynamic = (rasterized * hv.DynamicMap(self.adh_mod.wmts.view) *
self.adh_mod.polys * self.adh_mod.points *
edgepaths_overlay)
elif meshes.label == 'vector':
# Apply the colormap and color range dynamically
paths = vectorfield_to_paths(meshes,
color='Magnitude',
magnitude='Magnitude',
scale=0.005)
rasterized = rasterize(paths,
aggregator='mean',
precompute=True).apply.opts(**opts)
dynamic = (rasterized * hv.DynamicMap(self.adh_mod.wmts.view) *
self.adh_mod.polys * self.adh_mod.points *
edgepaths_overlay)
# time = pn.panel(self.adh_mod, parameters=['time'], widgets={'time': pn.widgets.DiscretePlayer}, show_name=False, width=400)
# time = pn.panel(self.adh_mod.mesh.simulations[self.sim_selector], parameters=['time'], widgets={'time': pn.widgets.DiscretePlayer}, show_name=False, width=400)
# time = pn.panel(self.adh_mod.mesh.current_sim, parameters=['time'],
# widgets={'time': pn.widgets.DiscretePlayer}, show_name=False, width=400)
time = pn.panel(
self.param,
parameters=['selected_times'],
widgets={'selected_times': pn.widgets.DiscretePlayer},
show_name=False,
width=600)
hv_panel = pn.panel(dynamic)
if self.view_analysis:
# todo going to have to combine the dynamic maps for meshes/vectorization/moving_points
# self.map_pane = pn.Column(hv_panel[0] * self.annotator.moving_points, pn.Row(pn.Spacer(width=100), time))
# create the sections of the trimesh
self.sections = meshes.apply(
self.adh_mod._sample, streams=[self.adh_mod.poly_stream])
point_x = PointerX(source=self.sections, x=0)
self.vline = hv.DynamicMap(hv.VLine, streams=[point_x])
self.moving_points = self.sections.apply(
self.adh_mod._pos_indicator, streams=[point_x])
self.analysis_pane = pn.Column(
(self.sections * self.vline).redim.range(
Depth=(0, 100),
Distance=(0, 20000)).opts(framewise=True))
self.map_pane = pn.Column(hv_panel[0],
pn.Row(pn.Spacer(width=80), time))
else:
self.map_pane = pn.Column(hv_panel[0],
pn.Row(pn.Spacer(width=80), time))
self.analysis_pane = pn.Spacer()
