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