def test_redim_dimension_values_cache_reset_1D(self): # Setting the values should drop mismatching keys from the cache fn = lambda i: Curve([i,i]) dmap = DynamicMap(fn, kdims=['i'])[{0,1,2,3,4,5}] self.assertEqual(dmap.keys(), [0,1,2,3,4,5]) redimmed = dmap.redim.values(i=[2,3,5,6,8]) self.assertEqual(redimmed.keys(), [2,3,5])
def test_dynamic_collate_ndlayout(self): def callback(): return NdLayout({i: Image(np.array([[i, 1], [2, 3]])) for i in range(1, 3)}) dmap = DynamicMap(callback, kdims=[]) layout = dmap.collate() self.assertEqual(list(layout.keys()), [1, 2]) self.assertEqual(layout[1][()], Image(np.array([[1, 1], [2, 3]])))
def test_deep_apply_transform_element_type(self): fn = lambda i: Curve(np.arange(i)) dmap = DynamicMap(fn, kdims=[Dimension('Test', range=(10, 20))]) dmap[10] mapped = dmap.apply(lambda x: Scatter(x)) area = mapped[11] self.assertEqual(area, Scatter(fn(11)))
def test_dynamic_collate_layout(self): def callback(): return Image(np.array([[0, 1], [2, 3]])) + Text(0, 0, 'Test') dmap = DynamicMap(callback, kdims=[]) layout = dmap.collate() self.assertEqual(list(layout.keys()), [('Image', 'I'), ('Text', 'I')]) self.assertEqual(layout.Image.I[()], Image(np.array([[0, 1], [2, 3]])))
def test_redim_dimension_values_cache_reset_2D_multi(self): # Setting the values should drop mismatching keys from the cache fn = lambda i,j: Curve([i,j]) keys = [(0,1),(1,0),(2,2),(2,5), (3,3)] dmap = DynamicMap(fn, kdims=['i','j'])[keys] self.assertEqual(dmap.keys(), keys) redimmed = dmap.redim.values(i=[2,10,50], j=[5,50,100]) self.assertEqual(redimmed.keys(), [(2,5)])
def test_periodic_param_fn_blocking(self): def callback(x): return Curve([1,2,3]) xval = Stream.define('x',x=0)() dmap = DynamicMap(callback, streams=[xval]) # Add stream subscriber mocking plot xval.add_subscriber(lambda **kwargs: dmap[()]) dmap.periodic(0.01, 100, param_fn=lambda i: {'x':i}) self.assertEqual(xval.x, 100)
def test_dynamic_split_overlays_on_ndoverlay(self): dmap = DynamicMap(lambda: NdOverlay({i: Points([i]) for i in range(3)})) initialize_dynamic(dmap) keys, dmaps = dmap._split_overlays() self.assertEqual(keys, [(0,), (1,), (2,)]) self.assertEqual(dmaps[0][()], Points([0])) self.assertEqual(dmaps[1][()], Points([1])) self.assertEqual(dmaps[2][()], Points([2]))
def test_dynamic_reindex_reorder(self): def history_callback(x, y, history=deque(maxlen=10)): history.append((x, y)) return Points(list(history)) dmap = DynamicMap(history_callback, kdims=['x', 'y']) reindexed = dmap.reindex(['y', 'x']) points = reindexed[2, 1] self.assertEqual(points, Points([(1, 2)]))
def test_dynamic_collate_layout_raise_no_remapping_error(self): def callback(x, y): return Image(np.array([[0, 1], [2, 3]])) + Text(0, 0, 'Test') stream = PointerXY() cb_callable = Callable(callback) dmap = DynamicMap(cb_callable, kdims=[], streams=[stream]) with self.assertRaisesRegexp(ValueError, 'The following streams are set to be automatically linked'): dmap.collate()
def test_dynamic_collate_layout_raise_ambiguous_remapping_error(self): def callback(x, y): return Image(np.array([[0, 1], [2, 3]])) + Image(np.array([[0, 1], [2, 3]])) stream = PointerXY() cb_callable = Callable(callback, stream_mapping={'Image': [stream]}) dmap = DynamicMap(cb_callable, kdims=[], streams=[stream]) with self.assertRaisesRegexp(ValueError, 'The stream_mapping supplied on the Callable is ambiguous'): dmap.collate()
def test_dynamic_event_renaming_valid(self): def fn(x1, y1): return Scatter([(x1, y1)]) xy = PointerXY(rename={'x':'x1','y':'y1'}) dmap = DynamicMap(fn, kdims=[], streams=[xy]) dmap.event(x1=1, y1=2)
def test_dynamic_collate_gridspace_with_changing_items_raises(self): def callback(i): return GridSpace({j: Curve([], label=str(j)) for j in range(i)}, 'X') dmap = DynamicMap(callback, kdims=['i']).redim.range(i=(2, 10)) layout = dmap.collate() dmap1, dmap2 = layout.values() err = 'Collated DynamicMaps must return GridSpace with consistent number of items.' with self.assertRaisesRegexp(ValueError, err): dmap1[4]
def test_dynamic_collate_layout_with_spec_stream_mapping(self): def callback(x, y): return Image(np.array([[0, 1], [2, 3]])) + Text(0, 0, 'Test') stream = PointerXY() cb_callable = Callable(callback, stream_mapping={'Image': [stream]}) dmap = DynamicMap(cb_callable, kdims=[], streams=[stream]) layout = dmap.collate() self.assertEqual(list(layout.keys()), [('Image', 'I'), ('Text', 'I')]) self.assertIs(stream.source, layout.Image.I)
def test_dynamic_collate_ndlayout_with_key_stream_mapping(self): def callback(x, y): return NdLayout({i: Image(np.array([[i, 1], [2, 3]])) for i in range(1, 3)}) stream = PointerXY() cb_callable = Callable(callback, stream_mapping={(1,): [stream]}) dmap = DynamicMap(cb_callable, kdims=[], streams=[stream]) layout = dmap.collate() self.assertEqual(list(layout.keys()), [1, 2]) self.assertIs(stream.source, layout[1])
def test_dynamic_collate_grid(self): def callback(): return GridSpace({(i, j): Image(np.array([[i, j], [2, 3]])) for i in range(1, 3) for j in range(1, 3)}) dmap = DynamicMap(callback, kdims=[]) grid = dmap.collate() self.assertEqual(list(grid.keys()), [(i, j) for i in range(1, 3) for j in range(1, 3)]) self.assertEqual(grid[(0, 1)][()], Image(np.array([[1, 1], [2, 3]])))
def test_dynamic_reindex_drop_raises_exception(self): def history_callback(x, y, history=deque(maxlen=10)): history.append((x, y)) return Points(list(history)) dmap = DynamicMap(history_callback, kdims=['x', 'y']) exception = ("DynamicMap does not allow dropping dimensions, " "reindex may only be used to reorder dimensions.") with self.assertRaisesRegexp(ValueError, exception): dmap.reindex(['x'])
def test_dynamic_collate_layout_with_changing_label(self): def callback(i): return Layout([Curve([], label=str(j)) for j in range(i, i+2)]) dmap = DynamicMap(callback, kdims=['i']).redim.range(i=(0, 10)) layout = dmap.collate() dmap1, dmap2 = layout.values() el1, el2 = dmap1[2], dmap2[2] self.assertEqual(el1.label, '2') self.assertEqual(el2.label, '3')
def test_dynamic_event_renaming_invalid(self): def fn(x1, y1): return Scatter([(x1, y1)]) xy = PointerXY(rename={'x':'x1','y':'y1'}) dmap = DynamicMap(fn, kdims=[], streams=[xy]) regexp = '(.+?)do not correspond to stream parameters' with self.assertRaisesRegexp(KeyError, regexp): dmap.event(x=1, y=2)
def test_dynamic_collate_grid_with_key_stream_mapping(self): def callback(): return GridSpace({(i, j): Image(np.array([[i, j], [2, 3]])) for i in range(1, 3) for j in range(1, 3)}) stream = PointerXY() cb_callable = Callable(callback, stream_mapping={(1, 2): [stream]}) dmap = DynamicMap(cb_callable, kdims=[]) grid = dmap.collate() self.assertEqual(list(grid.keys()), [(i, j) for i in range(1, 3) for j in range(1, 3)]) self.assertEqual(stream.source, grid[(1, 2)])
def test_periodic_param_fn_blocking_timeout(self): def callback(x): return Curve([1,2,3]) xval = Stream.define('x',x=0)() dmap = DynamicMap(callback, streams=[xval]) # Add stream subscriber mocking plot xval.add_subscriber(lambda **kwargs: dmap[()]) start = time.time() dmap.periodic(0.5, 100, param_fn=lambda i: {'x':i}, timeout=3) end = time.time() self.assertEqual((end - start) < 5, True)
class DynamicTransferStreams(ComparisonTestCase): 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_dynamic_redim_inherits_streams(self): redimmed = self.dmap.redim.range(z=(0, 5)) self.assertEqual(redimmed.streams, self.dmap.streams) def test_dynamic_relabel_inherits_streams(self): relabelled = self.dmap.relabel(label='Test') self.assertEqual(relabelled.streams, self.dmap.streams) def test_dynamic_map_inherits_streams(self): mapped = self.dmap.map(lambda x: x, Curve) self.assertEqual(mapped.streams, self.dmap.streams) def test_dynamic_select_inherits_streams(self): selected = self.dmap.select(Curve, x=(0, 5)) self.assertEqual(selected.streams, self.dmap.streams) def test_dynamic_hist_inherits_streams(self): hist = self.dmap.hist(adjoin=False) self.assertEqual(hist.streams, self.dmap.streams) def test_dynamic_mul_inherits_dim_streams(self): hist = self.dmap * self.dmap self.assertEqual(hist.streams, self.dmap.streams[1:]) def test_dynamic_util_inherits_dim_streams(self): hist = Dynamic(self.dmap) self.assertEqual(hist.streams, self.dmap.streams[1:]) 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_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])
def test_dynamic_collate_gridspace_with_changing_item_types_raises(self): def callback(i): eltype = Image if i%2 else Curve return GridSpace({j: eltype([], label=str(j)) for j in range(i, i+2)}, 'X') dmap = DynamicMap(callback, kdims=['i']).redim.range(i=(2, 10)) layout = dmap.collate() dmap1, dmap2 = layout.values() err = ('The objects in a GridSpace returned by a DynamicMap must ' 'consistently return the same number of items of the same type.') with self.assertRaisesRegexp(ValueError, err): dmap1[3]
def test_dynamic_groupby_kdims_and_streams(self): def plot_function(mydim, data): return Scatter(data[data[:, 2]==mydim]) buff = Buffer(data=np.empty((0, 3))) dmap = DynamicMap(plot_function, streams=[buff], kdims='mydim').redim.values(mydim=[0, 1, 2]) ndlayout = dmap.groupby('mydim', container_type=NdLayout) self.assertIsInstance(ndlayout[0], DynamicMap) data = np.array([(0, 0, 0), (1, 1, 1), (2, 2, 2)]) buff.send(data) self.assertEqual(ndlayout[0][()], Scatter([(0, 0)])) self.assertEqual(ndlayout[1][()], Scatter([(1, 1)])) self.assertEqual(ndlayout[2][()], Scatter([(2, 2)]))
def test_periodic_param_fn_non_blocking(self): def callback(x): return Curve([1,2,3]) xval = Stream.define('x',x=0)() dmap = DynamicMap(callback, streams=[xval]) # Add stream subscriber mocking plot xval.add_subscriber(lambda **kwargs: dmap[()]) self.assertNotEqual(xval.x, 100) dmap.periodic(0.0001, 100, param_fn=lambda i: {'x': i}, block=False) time.sleep(2) if not dmap.periodic.instance.completed: raise RuntimeError('Periodic callback timed out.') dmap.periodic.stop() self.assertEqual(xval.x, 100)
def test_dynamic_split_overlays_on_varying_order_overlay(self): def cb(i): if i%2 == 0: return Curve([]) * Points([]) else: return Points([]) * Curve([]) dmap = DynamicMap(cb, kdims='i').redim.range(i=(0, 4)) initialize_dynamic(dmap) keys, dmaps = dmap._split_overlays() self.assertEqual(keys, [('Curve', 'I'), ('Points', 'I')]) self.assertEqual(dmaps[0][0], Curve([])) self.assertEqual(dmaps[0][1], Curve([])) self.assertEqual(dmaps[1][0], Points([])) self.assertEqual(dmaps[1][1], Points([]))
def test_periodic_param_fn_non_blocking(self): def callback(x): return Curve([1,2,3]) xval = Stream.define('x',x=0)() dmap = DynamicMap(callback, streams=[xval]) # Add stream subscriber mocking plot xval.add_subscriber(lambda **kwargs: dmap[()]) dmap.periodic(0.0001, 1000, param_fn=lambda i: {'x':i}, block=False) self.assertNotEqual(xval.x, 1000) for i in range(1000): time.sleep(0.01) if dmap.periodic.instance.completed: break dmap.periodic.stop() self.assertEqual(xval.x, 1000)
def test_dynamic_split_overlays_on_missing_item_in_overlay(self): def cb(i): if i%2 == 0: return Curve([]) * Points([]) else: return Scatter([]) * Curve([]) dmap = DynamicMap(cb, kdims='i').redim.range(i=(0, 4)) initialize_dynamic(dmap) keys, dmaps = dmap._split_overlays() self.assertEqual(keys, [('Curve', 'I'), ('Points', 'I')]) self.assertEqual(dmaps[0][0], Curve([])) self.assertEqual(dmaps[0][1], Curve([])) self.assertEqual(dmaps[1][0], Points([])) with self.assertRaises(KeyError): dmaps[1][1]
def test_dynamic_opts_link_inputs(self): stream = LinkedStream() inputs = [DynamicMap(lambda: None, streams=[stream])] dmap = DynamicMap(Callable(lambda X: TestObj(None), inputs=inputs), kdims=['X']).redim.range(X=(0,10)) styled_dmap = dmap.options(plot_opt1='red', clone=False) opts = Store.lookup_options('backend_1', dmap[0], 'plot') self.assertEqual(opts.options, {'plot_opt1': 'red'}) self.assertIs(styled_dmap, dmap) self.assertTrue(dmap.callback.link_inputs) unstyled_dmap = dmap.callback.inputs[0].callback.inputs[0] opts = Store.lookup_options('backend_1', unstyled_dmap[0], 'plot') self.assertEqual(opts.options, {}) original_dmap = unstyled_dmap.callback.inputs[0] self.assertIs(stream, original_dmap.streams[0])
def test_periodic_counter_blocking(self): class Counter(object): def __init__(self): self.count = 0 def __call__(self): self.count += 1 return Curve([1,2,3]) next_stream = Stream.define('Next')() counter = Counter() dmap = DynamicMap(counter, streams=[next_stream]) # Add stream subscriber mocking plot next_stream.add_subscriber(lambda **kwargs: dmap[()]) dmap.periodic(0.01, 100) self.assertEqual(counter.count, 100)
def test_dynamic_compute_overlayable_zorders_two_deep_dynamic_layers(self): area = DynamicMap(lambda: Area(range(10)), kdims=[]) curve = DynamicMap(lambda: Curve(range(10)), kdims=[]) area_redim = area.redim(x='x2') curve_redim = curve.redim(x='x2') combined = area_redim*curve_redim combined[()] sources = compute_overlayable_zorders(combined) self.assertIn(area_redim, sources[0]) self.assertIn(area, sources[0]) self.assertNotIn(curve_redim, sources[0]) self.assertNotIn(curve, sources[0]) self.assertIn(curve_redim, sources[1]) self.assertIn(curve, sources[1]) self.assertNotIn(area_redim, sources[1]) self.assertNotIn(area, sources[1])
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_element_overlay(self): fn = lambda i: Image(sine_array(0,i)) dmap=DynamicMap(fn, kdims=['i']) dynamic_overlay = dmap * Image(sine_array(0,10)) overlaid = Image(sine_array(0,5)) * Image(sine_array(0,10)) self.assertEqual(dynamic_overlay[5], overlaid)
def test_deep_redim_dimension_name(self): fn = lambda i: Image(sine_array(0, i)) dmap = DynamicMap(fn).redim(x='X') self.assertEqual(dmap[0].kdims[0].name, 'X')
def test_redim_dimension_unit_aux(self): fn = lambda i: Image(sine_array(0,i)) dmap = DynamicMap(fn, kdims=['i']).redim.unit(i='m/s') self.assertEqual(dmap.kdims[0].unit, 'm/s')
def test_deep_redim_dimension_name_with_spec(self): fn = lambda i: Image(sine_array(0,i)) dmap = DynamicMap(fn, kdims=['i']).redim(Image, x='X') self.assertEqual(dmap[0].kdims[0].name, 'X')
def test_deep_getitem_cross_product_and_slice(self): fn = lambda i: Curve(np.arange(i)) dmap = DynamicMap(fn, kdims=[Dimension('Test', range=(10, 20))]) self.assertEqual(dmap[[10, 11, 12], 5:10], dmap.clone([(i, fn(i)[5:10]) for i in range(10, 13)]))
def test_mixed_kdim_streams_unbounded(self): dmap=DynamicMap(lambda x,y,z: x+y, kdims=['z'], streams=[XY()]) self.assertEqual(dmap.unbounded, ['z'])
def test_mixed_kdim_streams_bounded_redim(self): dmap=DynamicMap(lambda x,y,z: x+y, kdims=['z'], streams=[XY()]) self.assertEqual(dmap.redim.range(z=(-0.5,0.5)).unbounded, [])
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_kdims(self): DynamicMap(lambda x: x, kdims=['test'])
def test_simple_constructor_invalid_no_kdims(self): regexp = ("Callable '<lambda>' accepts more positional arguments than there are " "kdims and stream parameters") with self.assertRaisesRegexp(KeyError, regexp): DynamicMap(lambda x: x)
def test_sampled_bounded_init(self): fn = lambda i: Image(sine_array(0, i)) dmap = DynamicMap(fn, sampled=True)
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])
def test_sampled_unbounded_resample(self): fn = lambda i: Image(sine_array(0,i)) dmap=DynamicMap(fn, kdims=['i']) self.assertEqual(dmap[{0, 1, 2}].keys(), [0, 1, 2]) self.assertEqual(dmap.unbounded, ['i'])
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_sampled_unbounded_init(self): fn = lambda i: Image(sine_array(0,i)) dmap=DynamicMap(fn, kdims=['i']) self.assertEqual(dmap.unbounded, ['i'])
def test_deep_getitem_index_and_slice(self): fn = lambda i: Curve(np.arange(i)) dmap = DynamicMap(fn, kdims=[Dimension('Test', range=(10, 20))]) self.assertEqual(dmap[10, 5:10], fn(10)[5:10])
def test_callable_bounded_clone(self): fn = lambda i: Image(sine_array(0,i)) dmap=DynamicMap(fn, kdims=[Dimension('dim', range=(0,10))]) self.assertEqual(dmap, dmap.clone()) self.assertEqual(dmap.unbounded, [])
def test_deep_getitem_bounded_kdims_and_vdims(self): fn = lambda i: Curve(np.arange(i)) dmap = DynamicMap(fn, kdims=[Dimension('Test', range=(10, 20))]) self.assertEqual(dmap[:, 5:10, 0:5][10], fn(10)[5:10, 0:5])
def test_deep_map_apply_element_function(self): fn = lambda i: Curve(np.arange(i)) dmap = DynamicMap(fn, kdims=[Dimension('Test', range=(10, 20))]) mapped = dmap.map(lambda x: x.clone(x.data*2), Curve) curve = fn(10) self.assertEqual(mapped[10], curve.clone(curve.data*2))
def test_redim_dimension_type_aux(self): fn = lambda i: Image(sine_array(0,i)) dmap = DynamicMap(fn, kdims=['i']).redim.type(i=int) self.assertEqual(dmap.kdims[0].type, int)
def test_deep_relabel_group(self): fn = lambda i: Image(sine_array(0, i)) dmap = DynamicMap(fn).relabel(group='Test') self.assertEqual(dmap[0].group, 'Test')
def test_callable_bounded_init(self): fn = lambda i: Image(sine_array(0, i)) dmap = DynamicMap(fn, kdims=[Dimension('dim', range=(0, 10))])
def test_sampled_bounded_resample(self): fn = lambda i: Image(sine_array(0, i)) dmap = DynamicMap(fn, sampled=True) self.assertEqual(dmap[{0, 1, 2}].keys(), [0, 1, 2])
def test_redim_dimension_name(self): fn = lambda i: Image(sine_array(0, i)) dmap = DynamicMap(fn).redim(Default='New') self.assertEqual(dmap.kdims[0].name, 'New')
def test_simple_constructor_invalid(self): regexp = ("Callback '<lambda>' signature over \['x'\] does not accommodate " "required kdims \['x', 'y'\]") with self.assertRaisesRegexp(KeyError, regexp): DynamicMap(lambda x: x, kdims=['x','y'])
def test_dynamic_element_underlay(self): fn = lambda i: Image(sine_array(0, i)) dmap = DynamicMap(fn, sampled=True) dynamic_overlay = Image(sine_array(0, 10)) * dmap overlaid = Image(sine_array(0, 10)) * Image(sine_array(0, 5)) self.assertEqual(dynamic_overlay[5], overlaid)
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_redim_dimension_range_aux(self): fn = lambda i: Image(sine_array(0,i)) dmap = DynamicMap(fn, kdims=['i']).redim.range(i=(0,1)) self.assertEqual(dmap.kdims[0].range, (0,1))
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))