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_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 = 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_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_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()