def test_element_dynamic_with_instance_param(self):
curve = Curve([1, 2, 3])
inst = ParamClass(label='Test')
applied = TestOperation(curve, label=inst.param.label)
self.assertEqual(len(applied.streams), 1)
self.assertIsInstance(applied.streams[0], Params)
self.assertEqual(applied.streams[0].parameters, ['label'])
self.assertEqual(applied[()], curve.relabel('Test'))
def cb(X):
return NdOverlay({i: Curve(np.arange(10) + i) for i in range(X)})
def test_empty_element_visibility(self):
curve = Curve([])
plot = bokeh_renderer.get_plot(curve)
self.assertTrue(plot.handles['glyph_renderer'].visible)
def callback(i):
return GridSpace({j: Curve([], label=str(j))
for j in range(i)}, 'X')
def test_overlay_apply_ranges_disabled(self):
overlay = (Curve(range(10)) * Curve(range(10))).options(
'Curve', apply_ranges=False)
plot = mpl_renderer.get_plot(overlay)
self.assertTrue(all(
np.isnan(e) for e in plot.get_extents(overlay, {})))
def __call__(self):
self.count += 1
return Curve([1, 2, 3])
def callback(i):
return Layout([Curve([], label=str(j)) for j in range(i, i + 2)])
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_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_categorical_overlay_dimension_values(self):
curve = Curve([('C', 1), ('B', 3)]).redim.values(x=['A', 'B', 'C'])
scatter = Scatter([('A', 2)])
plot = bokeh_renderer.get_plot(curve * scatter)
x_range = plot.handles['x_range']
self.assertEqual(x_range.factors, ['A', 'B', 'C'])
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_overlay_projection_propagates(self):
overlay = Curve([]) * Curve([]).options(projection='custom')
plot = bokeh_renderer.get_plot(overlay)
self.assertEqual([p.projection for p in plot.subplots.values()],
['custom', 'custom'])
def test_overlay_projection_clashing(self):
overlay = Curve([]).options(projection='polar') * Curve(
[]).options(projection='custom')
with self.assertRaises(Exception):
bokeh_renderer.get_plot(overlay)
def test_element_data_aspect_responsive(self):
curve = Curve([0, 2]).opts(data_aspect=1, responsive=True)
plot = bokeh_renderer.get_plot(curve)
self.assertEqual(plot.state.aspect_ratio, 0.5)
self.assertEqual(plot.state.aspect_scale, 1)
self.assertEqual(plot.state.sizing_mode, 'scale_both')
class TestApplyElement(ComparisonTestCase):
def setUp(self):
self.element = Curve([1, 2, 3])
def test_element_apply_simple(self):
applied = self.element.apply(lambda x: x.relabel('Test'))
self.assertEqual(applied, self.element.relabel('Test'))
def test_element_apply_method_as_string(self):
applied = self.element.apply('relabel', label='Test')
self.assertEqual(applied, self.element.relabel('Test'))
def test_element_apply_with_kwarg(self):
applied = self.element.apply(lambda x, label: x.relabel(label), label='Test')
self.assertEqual(applied, self.element.relabel('Test'))
def test_element_apply_not_dynamic_with_instance_param(self):
pinst = ParamClass()
applied = self.element.apply(lambda x, label: x.relabel(label), label=pinst.param.label, dynamic=False)
self.assertEqual(applied, self.element.relabel('Test'))
def test_element_apply_not_dynamic_with_method_string(self):
pinst = ParamClass()
applied = self.element.apply('relabel', dynamic=False, label=pinst.param.label)
self.assertEqual(applied, self.element.relabel('Test'))
def test_element_apply_not_dynamic_with_param_method(self):
pinst = ParamClass()
applied = self.element.apply(lambda x, label: x.relabel(label), label=pinst.dynamic_label, dynamic=False)
self.assertEqual(applied, self.element.relabel('Test!'))
def test_element_apply_dynamic(self):
applied = self.element.apply(lambda x: x.relabel('Test'), dynamic=True)
self.assertEqual(len(applied.streams), 0)
self.assertEqual(applied[()], self.element.relabel('Test'))
def test_element_apply_dynamic_with_kwarg(self):
applied = self.element.apply(lambda x, label: x.relabel(label), dynamic=True, label='Test')
self.assertEqual(len(applied.streams), 0)
self.assertEqual(applied[()], self.element.relabel('Test'))
def test_element_apply_dynamic_element_method(self):
pinst = ParamClass()
applied = self.element.apply(self.element.relabel, label=pinst.param.label)
# Check stream
self.assertEqual(len(applied.streams), 1)
stream = applied.streams[0]
self.assertIsInstance(stream, Params)
self.assertEqual(stream.parameterized, pinst)
self.assertEqual(stream.parameters, [pinst.param.label])
# Check results
self.assertEqual(applied[()], self.element.relabel('Test'))
pinst.label = 'Another label'
self.assertEqual(applied[()], self.element.relabel('Another label'))
def test_element_apply_dynamic_with_instance_param(self):
pinst = ParamClass()
applied = self.element.apply(lambda x, label: x.relabel(label), label=pinst.param.label)
# Check stream
self.assertEqual(len(applied.streams), 1)
stream = applied.streams[0]
self.assertIsInstance(stream, Params)
self.assertEqual(stream.parameterized, pinst)
self.assertEqual(stream.parameters, [pinst.param.label])
# Check results
self.assertEqual(applied[()], self.element.relabel('Test'))
pinst.label = 'Another label'
self.assertEqual(applied[()], self.element.relabel('Another label'))
def test_element_apply_param_method_with_dependencies(self):
pinst = ParamClass()
applied = self.element.apply(pinst.apply_label)
# Check stream
self.assertEqual(len(applied.streams), 1)
stream = applied.streams[0]
self.assertIsInstance(stream, ParamMethod)
self.assertEqual(stream.parameterized, pinst)
self.assertEqual(stream.parameters, [pinst.param.label])
# Check results
self.assertEqual(applied[()], self.element.relabel('Test'))
pinst.label = 'Another label'
self.assertEqual(applied[()], self.element.relabel('Another label'))
def test_element_apply_dynamic_with_param_method(self):
pinst = ParamClass()
applied = self.element.apply(lambda x, label: x.relabel(label), label=pinst.dynamic_label)
# Check stream
self.assertEqual(len(applied.streams), 1)
stream = applied.streams[0]
self.assertIsInstance(stream, ParamMethod)
self.assertEqual(stream.parameterized, pinst)
self.assertEqual(stream.parameters, [pinst.param.label])
# Check result
self.assertEqual(applied[()], self.element.relabel('Test!'))
pinst.label = 'Another label'
self.assertEqual(applied[()], self.element.relabel('Another label!'))
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_element_xaxis_top(self):
curve = Curve(range(10)).options(xaxis='top')
plot = bokeh_renderer.get_plot(curve)
xaxis = plot.handles['xaxis']
self.assertTrue(xaxis in plot.state.above)
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 callback(x):
return Curve([1, 2, 3])
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 callback(i):
return NdLayout(
{j: Curve([], label=str(j))
for j in range(i, i + 2)})
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_overlay_empty_layers(self):
overlay = Curve(range(10)) * NdOverlay()
plot = mpl_renderer.get_plot(overlay)
self.assertEqual(len(plot.subplots), 1)
def cb(i):
if i % 2 == 0:
return Curve([]) * Points([])
else:
return Scatter([]) * Curve([])
def test_overlay_empty_element_extent(self):
overlay = Curve([]).redim.range(x=(-10, 10)) * Scatter(
[]).redim.range(y=(-20, 20))
plot = mpl_renderer.get_plot(overlay)
extents = plot.get_extents(overlay, {})
self.assertEqual(extents, (-10, -20, 10, 20))
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_element_show_frame_disabled(self):
curve = Curve(range(10)).opts(plot=dict(show_frame=False))
plot = bokeh_renderer.get_plot(curve).state
self.assertEqual(plot.outline_line_alpha, 0)
def test_dynamic_keydim_not_memoize(self):
dmap = DynamicMap(lambda x: Curve([(0, x)]), kdims=['x'])
self.assertEqual(dmap[0], Curve([(0, 0)]))
self.assertEqual(dmap[1], Curve([(0, 1)]))
def test_element_no_yaxis(self):
curve = Curve(range(10)).opts(plot=dict(yaxis=None))
plot = bokeh_renderer.get_plot(curve).state
self.assertFalse(plot.yaxis[0].visible)
def test_dynamic_keydim_memoize(self):
dmap = DynamicMap(lambda x: Curve([(0, x)]), kdims=['x'])
self.assertIs(dmap[0], dmap[0])
def test_element_not_dynamic_with_param_method(self):
curve = Curve([1, 2, 3])
inst = ParamClass(label='Test')
applied = TestOperation(curve, dynamic=False, label=inst.dynamic_label)
self.assertEqual(applied, curve.relabel('Test!'))
def history_callback(x, history=deque(maxlen=10)):
if x is not None:
history.append(x)
return Curve(list(history))
def setUp(self):
self.element = Curve([1, 2, 3])
def test_categorical_dimension_type(self):
curve = Curve([]).redim.type(x=str)
plot = bokeh_renderer.get_plot(curve)
x_range = plot.handles['x_range']
self.assertEqual(x_range.factors, [])
