def test_dynamic_operation_link_inputs_not_transferred_on_clone(self):
fn = lambda i: Image(sine_array(0, i))
dmap = DynamicMap(fn, kdims=['i'])
dmap_with_fn = Dynamic(dmap,
link_inputs=False,
operation=lambda x: x.clone(x.data * 2))
self.assertTrue(dmap_with_fn.clone().callback.link_inputs)
def test_selection_expr_stream_dynamic_map(self):
for element_type in [Scatter, Points, Curve]:
# Create SelectionExpr on element
dmap = Dynamic(element_type(([1, 2, 3], [1, 5, 10])))
expr_stream = SelectionExpr(dmap)
# Check stream properties
self.assertEqual(len(expr_stream._source_streams), 1)
self.assertIsInstance(expr_stream._source_streams[0], BoundsXY)
self.assertIsNone(expr_stream.bbox)
self.assertIsNone(expr_stream.selection_expr)
# Simulate interactive update by triggering source stream
expr_stream._source_streams[0].event(bounds=(1, 1, 3, 4))
# Check SelectionExpr values
self.assertEqual(
repr(expr_stream.selection_expr),
repr((dim('x') >= 1) & (dim('x') <= 3) &
(dim('y') >= 1) & (dim('y') <= 4))
)
self.assertEqual(
expr_stream.bbox,
{'x': (1, 3), 'y': (1, 4)}
)
def test_dynamic_operation_with_kwargs(self):
fn = lambda i: Image(sine_array(0,i))
dmap=DynamicMap(fn, kdims=['i'])
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_dynamic_operation_on_element_dict(self):
img = Image(sine_array(0,5))
posxy = PointerXY(x=3, y=1)
dmap_with_fn = Dynamic(img, operation=lambda obj, x, y: obj.clone(obj.data*x+y),
streams=dict(x=posxy.param.x, y=posxy.param.y))
element = dmap_with_fn[()]
self.assertEqual(element, Image(sine_array(0,5)*3+1))
def test_dynamic_operation_on_element(self):
img = Image(sine_array(0,5))
posxy = PointerXY(x=2, y=1)
dmap_with_fn = Dynamic(img, operation=lambda obj, x, y: obj.clone(obj.data*x+y),
streams=[posxy])
element = dmap_with_fn[()]
self.assertEqual(element, Image(sine_array(0,5)*2+1))
self.assertEqual(dmap_with_fn.streams, [posxy])
def __init__(self, obj, paths=None, **params):
super(LineCrossSection, self).__init__(**params)
self.obj = obj
paths = [] if paths is None else paths
self.path = Path(paths, crs=ccrs.GOOGLE_MERCATOR)
self.path_stream = PolyDraw(source=self.path)
PolyEdit(source=self.path)
self.sections = Dynamic(self.obj,
operation=self._sample,
streams=[self.path_stream])
self.tiles = WMTS(self.tile_url)
def test_dynamicmap_legend_updates_add_dynamic_plots(self):
hmap = HoloMap({i: Overlay([Curve([1, 2, j], label=chr(65+j)) for j in range(i)]) for i in range(1, 4)})
dmap = Dynamic(hmap)
plot = bokeh_renderer.get_plot(dmap)
legend_labels = [item.label for item in plot.state.legend[0].items]
self.assertEqual(legend_labels, [{'value': 'A'}])
plot.update((2,))
legend_labels = [item.label for item in plot.state.legend[0].items]
self.assertEqual(legend_labels, [{'value': 'A'}, {'value': 'B'}])
plot.update((3,))
legend_labels = [item.label for item in plot.state.legend[0].items]
self.assertEqual(legend_labels, [{'value': 'A'}, {'value': 'B'}, {'value': 'C'}])
def test_dynamic_util_parameterized_method(self):
class Test(param.Parameterized):
label = param.String(default='test')
@param.depends('label')
def apply_label(self, obj):
return obj.relabel(self.label)
test = Test()
dmap = Dynamic(self.dmap, operation=test.apply_label)
test.label = 'custom label'
self.assertEqual(dmap[(0, 3)].label, 'custom label')
def test_dynamicmap_legend_updates(self):
hmap = HoloMap({i: Curve([1, 2, 3], label=chr(65+i+2)) * Curve([1, 2, 3], label='B')
for i in range(3)})
dmap = Dynamic(hmap)
plot = bokeh_renderer.get_plot(dmap)
legend_labels = [item.label for item in plot.state.legend[0].items]
self.assertEqual(legend_labels, [{'value': 'C'}, {'value': 'B'}])
plot.update((1,))
legend_labels = [item.label for item in plot.state.legend[0].items]
self.assertEqual(legend_labels, [{'value': 'D'}, {'value': 'B'}])
plot.update((2,))
legend_labels = [item.label for item in plot.state.legend[0].items]
self.assertEqual(legend_labels, [{'value': 'E'}, {'value': 'B'}])
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_dynamicmap_param_method_dynamic_operation(self):
inner = self.inner()
dmap = DynamicMap(inner.method)
inner_stream = dmap.streams[0]
op_dmap = Dynamic(dmap, operation=inner.op_method)
self.assertEqual(len(op_dmap.streams), 1)
stream = op_dmap.streams[0]
self.assertEqual(set(stream.parameters), {inner.param.y})
self.assertIsInstance(stream, ParamMethod)
self.assertEqual(stream.contents, {})
values_x, values_y = [], []
def subscriber_x(**kwargs):
values_x.append(kwargs)
def subscriber_y(**kwargs):
values_y.append(kwargs)
inner_stream.add_subscriber(subscriber_x)
stream.add_subscriber(subscriber_y)
inner.y = 3
self.assertEqual(values_x, [])
self.assertEqual(values_y, [{}])
def test_dynamic_util_inherits_dim_streams(self):
hist = Dynamic(self.dmap)
self.assertEqual(hist.streams, self.dmap.streams[1:])
return data.iloc[combine_selections(**kwargs)] if kwargs else data
from holoviews.streams import Stream, BoundsXY, BoundsX
geo_bounds = BoundsXY(source=static_geo, rename={'bounds': 'cenlon__cenlat'})
elev_bounds = BoundsXY(source=static_elev,
rename={'bounds': 'dem_mean_elev__cenlat'})
temp_bounds = BoundsX(source=static_temp,
rename={'boundsx': 'tstar_avg_temp_mean_elev'})
prcp_bounds = BoundsX(source=static_prcp, rename={'boundsx': 'tstar_avg_prcp'})
selections = [geo_bounds, elev_bounds, temp_bounds, prcp_bounds]
dyn_data = hv.DynamicMap(select_data, streams=selections)
dyn_count = Dynamic(dyn_data, operation=count)
geomap = geo_bg * static_geo * Dynamic(dyn_data, operation=geo)
elevation = static_elev * Dynamic(dyn_data, operation=elev)
temperature = static_temp * Dynamic(dyn_data, operation=temp)
precipitation = static_prcp * Dynamic(dyn_data, operation=prcp)
def clear_selections(arg=None):
geo_bounds.update(bounds=None)
elev_bounds.update(bounds=None)
temp_bounds.update(boundsx=None)
prcp_bounds.update(boundsx=None)
Stream.trigger(selections)
def test_dynamic_operation_link_inputs_not_transferred_on_clone(self):
fn = lambda i: Image(sine_array(0,i))
dmap=DynamicMap(fn, kdims=['i'])
dmap_with_fn = Dynamic(dmap, link_inputs=False, operation=lambda x: x.clone(x.data*2))
self.assertTrue(dmap_with_fn.clone().callback.link_inputs)
def test_dynamic_operation_on_hmap(self):
hmap = HoloMap({i: Image(sine_array(0, i)) for i in range(10)})
dmap = Dynamic(hmap, operation=lambda x: x)
self.assertEqual(dmap.kdims[0].name, hmap.kdims[0].name)
self.assertEqual(dmap.kdims[0].values, hmap.keys())
def test_dynamic_operation(self):
fn = lambda i: Image(sine_array(0, i))
dmap = DynamicMap(fn, kdims=['i'])
dmap_with_fn = Dynamic(dmap, operation=lambda x: x.clone(x.data * 2))
self.assertEqual(dmap_with_fn[5], Image(sine_array(0, 5) * 2))
def test_dynamic_util_inherits_dim_streams_clash(self):
exception = (
"The supplied stream objects PointerX\(x=None\) and "
"PointerX\(x=0\) clash on the following parameters: \['x'\]")
with self.assertRaisesRegexp(Exception, exception):
Dynamic(self.dmap, streams=[PointerX])
