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])