def test_dynamic_overlay_memoization(self):
"""Tests that Callable memoizes unchanged callbacks"""
def fn(x, y):
return Scatter([(x, y)])
dmap = DynamicMap(fn, kdims=[], streams=[PositionXY()])
counter = [0]
def fn2(x, y):
counter[0] += 1
return Image(np.random.rand(10, 10))
dmap2 = DynamicMap(fn2, kdims=[], streams=[PositionXY()])
overlaid = dmap * dmap2
overlay = overlaid[()]
self.assertEqual(overlay.Scatter.I, fn(0, 0))
dmap.event(x=1, y=2)
overlay = overlaid[()]
# Ensure dmap return value was updated
self.assertEqual(overlay.Scatter.I, fn(1, 2))
# Ensure dmap2 callback was called only once
self.assertEqual(counter[0], 1)
def test_opts_method_dynamicmap_grouped(self):
dmap = DynamicMap(lambda X: Curve([1, 2, X]),
kdims=['X']).redim.range(X=(0, 3))
retval = dmap.opts({'plot': dict(width=700)})
assert retval is not dmap
self.assertEqual(
self.lookup_options(retval[0], 'plot').options, {'width': 700})
def test_opts_method_dynamicmap_grouped(self):
dmap = DynamicMap(lambda X: Curve([1, 2, X]),
kdims=['X']).redim.range(X=(0, 3))
retval = dmap.opts({'plot': dict(width=700)})
assert retval is not dmap
self.assertEqual(self.lookup_options(retval[0], 'plot').options,
{'width':700})
def test_dynamic_dynamicmap_overlay(self):
fn = lambda i: Image(sine_array(0, i))
dmap = DynamicMap(fn, sampled=True)
fn2 = lambda i: Image(sine_array(0, i * 2))
dmap2 = DynamicMap(fn2, sampled=True)
dynamic_overlay = dmap * dmap2
overlaid = Image(sine_array(0, 5)) * Image(sine_array(0, 10))
self.assertEqual(dynamic_overlay[5], overlaid)
def test_unique_keys_no_overlap_dynamicmap_initialized(self):
dmap1 = DynamicMap(lambda A: Curve(range(10)), kdims=['A'])
dmap2 = DynamicMap(lambda B: Curve(range(10)), kdims=['B'])
dmap1[0]
dmap2[1]
dims, keys = unique_dimkeys(dmap1 + dmap2)
self.assertEqual(dims, dmap1.kdims + dmap2.kdims)
self.assertEqual(keys, [(0, 1)])
def test_unique_keys_dmap_partial_overlap(self):
hmap1 = DynamicMap(lambda x: Curve(range(10)),
kdims=['x']).redim.values(x=[1, 2, 3])
hmap2 = DynamicMap(lambda x: Curve(range(10)),
kdims=['x']).redim.values(x=[1, 2, 3, 4])
dims, keys = unique_dimkeys(hmap1 + hmap2)
self.assertEqual(hmap2.kdims, dims)
self.assertEqual(keys, [(i, ) for i in range(1, 5)])
def test_unique_keys_dmap_cartesian_product(self):
hmap1 = DynamicMap(lambda x, y: Curve(range(10)),
kdims=['x', 'y']).redim.values(x=[1, 2, 3])
hmap2 = DynamicMap(lambda x, y: Curve(range(10)),
kdims=['x', 'y']).redim.values(y=[1, 2, 3])
dims, keys = unique_dimkeys(hmap1 + hmap2)
self.assertEqual(hmap1.kdims[:1] + hmap2.kdims[1:], dims)
self.assertEqual(keys,
[(x, y) for x in range(1, 4) for y in range(1, 4)])
def test_dynamic_values_partial_overlap(self):
kdims = [
Dimension('File', range=(0.01, 1)),
Dimension('SliceDimension', values=['x', 'y', 'z']),
Dimension('Coordinates', range=(0.01, 1))
]
dmap1 = DynamicMap(lambda x, y, z: Image(np.random.rand(10, 10)),
kdims=kdims)
dmap2 = DynamicMap(lambda x: Curve(np.random.rand(10, 2)) * VLine(x),
kdims=kdims[:1])
mpl_renderer.get_widget(dmap1 + dmap2, 'selection')
def test_dynamic_holomap_overlay(self):
fn = lambda i: Image(sine_array(0, i))
dmap = DynamicMap(fn, sampled=True)
hmap = HoloMap({i: Image(sine_array(0, i * 2)) for i in range(10)})
dynamic_overlay = dmap * hmap
overlaid = Image(sine_array(0, 5)) * Image(sine_array(0, 10))
self.assertEqual(dynamic_overlay[5], overlaid)
def test_dynamic_operation_with_kwargs(self):
fn = lambda i: Image(sine_array(0, i))
dmap = DynamicMap(fn, sampled=True)
def fn(x, multiplier=2):
return x.clone(x.data * multiplier)
dmap_with_fn = Dynamic(dmap, operation=fn, kwargs=dict(multiplier=3))
self.assertEqual(dmap_with_fn[5], Image(sine_array(0, 5) * 3))
def test_kdims_dynamic_map(self):
# Dynamic map with two key dimensions
dmap = DynamicMap(lambda kdim1: Scatter([kdim1, kdim1]),
kdims=["kdim1"]).redim.values(kdim1=[1, 2, 3, 4])
# Convert to Dash
components = to_dash(self.app, [dmap])
# Check returned components
self.assertIsInstance(components, DashComponents)
self.assertEqual(len(components.graphs), 1)
self.assertEqual(len(components.kdims), 1)
self.assertIsInstance(components.store, Store)
self.assertEqual(len(components.resets), 0)
# Get arguments passed to @app.callback decorator
decorator_args = list(self.app.callback.call_args_list[0])[0]
outputs, inputs, states = decorator_args
# Check outputs
expected_outputs = [(g.id, "figure") for g in components.graphs] + \
[(components.store.id, "data")]
self.assertEqual([(output.component_id, output.component_property)
for output in outputs], expected_outputs)
# Check inputs
expected_inputs = [
(g.id, prop) for g in components.graphs
for prop in ["selectedData", "relayoutData"]
] + [(list(components.kdims.values())[0].children[1].id, 'value')]
self.assertEqual(
[(ip.component_id, ip.component_property) for ip in inputs],
expected_inputs,
)
# Check State
expected_state = [(components.store.id, "data")]
self.assertEqual(
[(state.component_id, state.component_property)
for state in states],
expected_state,
)
# Get callback function
callback_fn = self.decorator.call_args_list[0][0][0]
# mimic initial callback invocation
store_value = encode_store_data({"streams": {}})
with patch.object(CallbackContext, "triggered", []):
[fig, new_store] = callback_fn({}, {}, 3, None, store_value)
# First figure is the scatter trace
self.assertEqual(fig["data"][0]["type"], "scatter")
self.assertEqual(list(fig["data"][0]["x"]), [0, 1])
self.assertEqual(list(fig["data"][0]["y"]), [3, 3])
def view(self):
helper = self.draw_helper
mesh_dmap = DynamicMap(Callable(self.gen_mesh, memoize=False), streams=[self])
if isinstance(helper, PolyAnnotator):
layout = (helper.tiles * helper.polys * mesh_dmap * helper.points +
helper.poly_table + helper.point_table)
else:
layout = (helper.tiles * helper.polys * mesh_dmap * helper.points +
helper.point_table)
return layout.options(shared_datasource=True, clone=False).cols(1)
def test_stream_callback(self):
dmap = DynamicMap(lambda x, y: Points([(x, y)]),
kdims=[],
streams=[PositionXY()])
plot = bokeh_renderer.get_plot(dmap)
bokeh_renderer(plot)
plot.callbacks[0].on_msg({"x": 10, "y": -10})
data = plot.handles['source'].data
self.assertEqual(data['x'], np.array([10]))
self.assertEqual(data['y'], np.array([-10]))
def test_dynamic_streams_refresh(self):
stream = PositionXY()
dmap = DynamicMap(lambda x, y: Points([(x, y)]),
kdims=[],
streams=[stream])
plot = mpl_renderer.get_plot(dmap)
plot.initialize_plot()
pre = mpl_renderer(plot, fmt='png')
stream.update(x=1, y=1)
plot.refresh()
post = mpl_renderer(plot, fmt='png')
self.assertNotEqual(pre, post)
def test_render_dynamicmap_with_dims(self):
dmap = DynamicMap(lambda y: Curve([1, 2, y]),
kdims=['y']).redim.range(y=(0.1, 5))
obj, _ = self.renderer._validate(dmap, None)
self.renderer.components(obj)
[(plot, pane)] = obj._plots.values()
cds = plot.handles['cds']
self.assertEqual(cds.data['y'][2], 0.1)
slider = obj.layout.select(FloatSlider)[0]
slider.value = 3.1
self.assertEqual(cds.data['y'][2], 3.1)
def test_generator_open_stopiteration(self):
generator = (Image(sine_array(0, i)) for i in range(10))
dmap = DynamicMap(generator)
for i in range(10):
el = next(dmap)
self.assertEqual(type(el), Image)
try:
el = next(dmap)
raise AssertionError("StopIteration not raised when expected")
except Exception as e:
if e.__class__ != StopIteration:
raise AssertionError("StopIteration was expected, got %s" % e)
def test_render_dynamicmap_with_stream(self):
stream = Stream.define(str('Custom'), y=2)()
dmap = DynamicMap(lambda y: Curve([1, 2, y]), kdims=['y'], streams=[stream])
obj, _ = self.renderer._validate(dmap, None)
self.renderer.components(obj)
[(plot, pane)] = obj._plots.values()
y = plot.handles['fig']['data'][0]['y']
self.assertEqual(y[2], 2)
stream.event(y=3)
y = plot.handles['fig']['data'][0]['y']
self.assertEqual(y[2], 3)
def test_stream_callback_single_call(self):
def history_callback(x, history=deque(maxlen=10)):
history.append(x)
return Curve(list(history))
stream = PositionX()
dmap = DynamicMap(history_callback, kdims=[], streams=[stream])
plot = plotly_renderer.get_plot(dmap)
plotly_renderer(plot)
for i in range(20):
stream.update(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 = PositionX()
dmap = DynamicMap(history_callback, kdims=[], streams=[stream])
plot = mpl_renderer.get_plot(dmap)
mpl_renderer(plot)
for i in range(20):
stream.update(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 = PositionX()
dmap = DynamicMap(history_callback, kdims=[], streams=[stream])
plot = bokeh_renderer.get_plot(dmap)
bokeh_renderer(plot)
for i in range(20):
stream.update(x=i)
data = plot.handles['source'].data
self.assertEqual(data['x'], np.arange(10))
self.assertEqual(data['y'], np.arange(10, 20))
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_render_dynamicmap_with_stream_dims(self):
stream = Stream.define(str('Custom'), y=2)()
dmap = DynamicMap(lambda x, y: Curve([x, 1, y]),
kdims=['x', 'y'],
streams=[stream]).redim.values(x=[1, 2, 3])
obj, _ = self.renderer._validate(dmap, None)
self.renderer.components(obj)
[(plot, pane)] = obj._plots.values()
cds = plot.handles['cds']
self.assertEqual(cds.data['y'][2], 2)
stream.event(y=3)
self.assertEqual(cds.data['y'][2], 3)
self.assertEqual(cds.data['y'][0], 1)
slider = obj.layout.select(DiscreteSlider)[0]
slider.value = 3
self.assertEqual(cds.data['y'][0], 3)
def test_stream_callback_with_ids(self):
dmap = DynamicMap(lambda x, y: Points([(x, y)]),
kdims=[],
streams=[PositionXY()])
plot = bokeh_renderer.get_plot(dmap)
bokeh_renderer(plot)
hover = plot.state.select(type=HoverTool)[0]
plot.callbacks[0].on_msg({
"x": {
'id': hover.ref['id'],
'value': 10
},
"y": {
'id': hover.ref['id'],
'value': -10
}
})
data = plot.handles['source'].data
self.assertEqual(data['x'], np.array([10]))
self.assertEqual(data['y'], np.array([-10]))
def __init__(self, skel_data, plot_function,
on_disk=None, on_disk_name="triflow_plot",
**renderer_args):
self.on_disk = None
self._plot_pipe = streams.Pipe(data=skel_data)
self._dynmap = (DynamicMap(plot_function,
streams=[self._plot_pipe])
.opts("Curve [width=600] {+framewise}"))
self._writers = []
if on_disk:
self._renderer = MPLRenderer.instance()
target_dir = Path(on_disk)
target_dir.makedirs_p()
def save_curves(data):
target_file = target_dir / "%s_%i" % (on_disk_name, data.i)
process = mp.Process(target=self._renderer.save,
args=(self.hv_curve, target_file),
kwargs=renderer_args)
self._writers.append(process)
process.start()
self._plot_pipe.add_subscriber(save_curves)
def test_callable_open_clone(self):
fn = lambda i: Image(sine_array(0,i))
dmap=DynamicMap(fn)
self.assertEqual(dmap, dmap.clone())
def map_view(self):
options = dict(tools=['box_select'], clone=False)
annotated = DynamicMap(self.annotated_points,
streams=[self.table_stream])
return self.tiles * self.polys * self.points.options(
**options) * annotated
def table_view(self):
return DynamicMap(self.group_table, streams=[self.table_stream])
def test_generator_closed_clone(self):
fn = lambda i: Image(sine_array(0,i))
dmap=DynamicMap(fn, kdims=[Dimension('dim', range=(0,10))])
self.assertEqual(dmap, dmap.clone())
def test_generator_open_clone(self):
generator = (Image(sine_array(0,i)) for i in range(10))
dmap=DynamicMap(generator)
self.assertEqual(dmap, dmap.clone())
def test_deep_getitem_cache_sliced(self):
fn = lambda i: Curve(np.arange(i))
dmap = DynamicMap(fn, kdims=[Dimension('Test', range=(10, 20))])
dmap[10] # Add item to cache
self.assertEqual(dmap[:, 5:10][10], fn(10)[5:10])
def test_generator_open_clone(self):
generator = (Image(sine_array(0, i)) for i in range(10))
dmap = DynamicMap(generator)
self.assertEqual(dmap, dmap.clone())
def test_generator_open_init(self):
generator = (Image(sine_array(0, i)) for i in range(10))
dmap = DynamicMap(generator)
self.assertEqual(dmap.mode, 'open')
def test_deep_select_slice_kdim_no_match(self):
fn = lambda i: Curve(np.arange(i))
dmap = DynamicMap(fn, kdims=[Dimension('Test', range=(10, 20))])
self.assertEqual(dmap.select(DynamicMap, x=(5, 10))[10], fn(10))
def test_deep_select_slice_kdim_and_vdims(self):
fn = lambda i: Curve(np.arange(i))
dmap = DynamicMap(fn, kdims=[Dimension('Test', range=(10, 20))])
self.assertEqual(
dmap.select(x=(5, 10), y=(0, 5))[10],
fn(10)[5:10, 0:5])
