def test_errorbars_line_width_op_update(self):
errorbars = HoloMap({
0: ErrorBars([(0, 0, 0.1, 0.2, 1), (0, 1, 0.2, 0.4, 4),
(0, 2, 0.6, 1.2, 8)], vdims=['y', 'perr', 'nerr', 'line_width']),
1: ErrorBars([(0, 0, 0.1, 0.2, 2), (0, 1, 0.2, 0.4, 6),
(0, 2, 0.6, 1.2, 4)], vdims=['y', 'perr', 'nerr', 'line_width'])
}).options(linewidth='line_width')
plot = mpl_renderer.get_plot(errorbars)
artist = plot.handles['artist']
self.assertEqual(artist.get_linewidths(), [1, 4, 8])
plot.update((1,))
self.assertEqual(artist.get_linewidths(), [2, 6, 4])
def test_errorbars_color_op_update(self):
errorbars = HoloMap({
0: ErrorBars([(0, 0, 0.1, 0.2, '#000000'), (0, 1, 0.2, 0.4, '#FF0000'),
(0, 2, 0.6, 1.2, '#00FF00')], vdims=['y', 'perr', 'nerr', 'color']),
1: ErrorBars([(0, 0, 0.1, 0.2, '#FF0000'), (0, 1, 0.2, 0.4, '#00FF00'),
(0, 2, 0.6, 1.2, '#0000FF')], vdims=['y', 'perr', 'nerr', 'color'])
}).options(color='color')
plot = mpl_renderer.get_plot(errorbars)
artist = plot.handles['artist']
self.assertEqual(artist.get_edgecolors(),
np.array([[0, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 1]]))
plot.update((1,))
self.assertEqual(artist.get_edgecolors(),
np.array([[1, 0, 0, 1], [0, 1, 0, 1], [0, 0, 1, 1]]))
def test_hover_tool_overlay_renderers(self):
overlay = Curve(range(2)).opts(tools=['hover']) * ErrorBars(
[]).opts(tools=['hover'])
plot = bokeh_renderer.get_plot(overlay)
self.assertEqual(len(plot.handles['hover'].renderers), 1)
self.assertEqual(plot.handles['hover'].tooltips, [('x', '@{x}'),
('y', '@{y}')])
def test_errorbars_linear_color_op(self):
errorbars = ErrorBars([(0, 0, 0.1, 0.2, 0), (0, 1, 0.2, 0.4, 1),
(0, 2, 0.6, 1.2, 2)],
vdims=['y', 'perr', 'nerr',
'color']).options(color='color')
with self.assertRaises(Exception):
mpl_renderer.get_plot(errorbars)
def test_overlay_points_errorbars(self, dynamic=False):
points = Points(self.data)
error = ErrorBars(self.data, kdims='x', vdims=['y', 'e'])
lnk_sel = link_selections.instance(unselected_color='#ff0000')
overlay = points * error
if dynamic:
overlay = hv.util.Dynamic(overlay)
linked = lnk_sel(overlay)
current_obj = linked[()]
# Check initial base layers
self.check_base_points_like(current_obj.Points.I, lnk_sel)
self.check_base_points_like(current_obj.ErrorBars.I, lnk_sel)
# Check initial selection layers
self.check_overlay_points_like(current_obj.Points.II, lnk_sel,
self.data)
self.check_overlay_points_like(current_obj.ErrorBars.II, lnk_sel,
self.data)
# Select first and third point
boundsxy = lnk_sel._selection_expr_streams[0]._source_streams[0]
boundsxy.event(bounds=(0, 0, 4, 2))
current_obj = linked[()]
# Check base layers haven't changed
self.check_base_points_like(current_obj.Points.I, lnk_sel)
self.check_base_points_like(current_obj.ErrorBars.I, lnk_sel)
# Check selected layers
self.check_overlay_points_like(current_obj.Points.II, lnk_sel,
self.data.iloc[[0, 2]])
self.check_overlay_points_like(current_obj.ErrorBars.II, lnk_sel,
self.data.iloc[[0, 2]])
def test_errorbars_categorical_color_op(self):
errorbars = ErrorBars([(0, 0, 0.1, 0.2, 'A'), (0, 1, 0.2, 0.4, 'B'),
(0, 2, 0.6, 1.2, 'C')],
vdims=['y', 'perr', 'nerr',
'color']).options(color='color')
with self.assertRaises(Exception):
mpl_renderer.get_plot(errorbars)
def test_errorbars_line_color_op(self):
errorbars = ErrorBars([(0, 0, 0.1, 0.2, '#000000'), (0, 1, 0.2, 0.4, '#FF0000'), (0, 2, 0.6, 1.2, '#00FF00')],
vdims=['y', 'perr', 'nerr', 'color']).options(edgecolor='color')
plot = mpl_renderer.get_plot(errorbars)
artist = plot.handles['artist']
self.assertEqual(artist.get_edgecolors(), np.array([
[0, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 1]]
))
def test_errorbars_line_width_op(self):
errorbars = ErrorBars([(0, 0, 0.1, 0.2, 1), (0, 1, 0.2, 0.4, 4),
(0, 2, 0.6, 1.2, 8)],
vdims=['y', 'perr', 'nerr', 'line_width'
]).options(linewidth='line_width')
plot = mpl_renderer.get_plot(errorbars)
artist = plot.handles['artist']
self.assertEqual(artist.get_linewidths(), [1, 4, 8])
def test_errorbars_padding_logx(self):
errorbars = ErrorBars([(1, 1, 0.5), (2, 2, 0.5),
(3, 3, 0.5)]).options(padding=0.1, logx=True)
plot = bokeh_renderer.get_plot(errorbars)
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
self.assertEqual(x_range.start, 0.89595845984076228)
self.assertEqual(x_range.end, 3.3483695221017129)
self.assertEqual(y_range.start, 0.19999999999999996)
self.assertEqual(y_range.end, 3.8)
def test_errorbars_padding_logy(self):
errorbars = ErrorBars([(1, 1, 0.5), (2, 2, 0.5),
(3, 3, 0.5)]).options(padding=0.1, logy=True)
plot = bokeh_renderer.get_plot(errorbars)
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
self.assertEqual(x_range.start, 0.8)
self.assertEqual(x_range.end, 3.2)
self.assertEqual(y_range.start, 0.41158562699652224)
self.assertEqual(y_range.end, 4.2518491541367327)
def test_errorbars_plot(self):
errorbars = ErrorBars([(0, 1, 0.5), (1, 2, 1), (2, 3, 2.25)], vdims=['y', 'y2'])
state = self._get_plot_state(errorbars)
self.assertEqual(state['data'][0]['x'], np.array([0, 1, 2]))
self.assertEqual(state['data'][0]['y'], np.array([1, 2, 3]))
self.assertEqual(state['data'][0]['error_y']['array'], np.array([0.5, 1, 2.25]))
self.assertEqual(state['data'][0]['error_y']['arrayminus'], np.array([0.5, 1, 2.25]))
self.assertEqual(state['data'][0]['mode'], 'lines')
self.assertEqual(state['layout']['yaxis']['range'], [0.5, 5.25])
def test_errorbars_padding_square(self):
errorbars = ErrorBars([(1, 1, 0.5), (2, 2, 0.5),
(3, 3, 0.5)]).options(padding=0.1)
plot = bokeh_renderer.get_plot(errorbars)
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
self.assertEqual(x_range.start, 0.8)
self.assertEqual(x_range.end, 3.2)
self.assertEqual(y_range.start, 0.19999999999999996)
self.assertEqual(y_range.end, 3.8)
def test_errorbars_line_width_op(self):
errorbars = ErrorBars([(0, 0, 0.1, 0.2, 1), (0, 1, 0.2, 0.4, 4),
(0, 2, 0.6, 1.2, 8)],
vdims=['y', 'perr', 'nerr', 'line_width'
]).options(line_width='line_width')
plot = bokeh_renderer.get_plot(errorbars)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
self.assertEqual(cds.data['line_width'], np.array([1, 4, 8]))
self.assertEqual(glyph.line_width, {'field': 'line_width'})
def test_errorbars_line_alpha_op(self):
errorbars = ErrorBars([(0, 0, 0.1, 0.2, 0), (0, 1, 0.2, 0.4, 0.2),
(0, 2, 0.6, 1.2, 0.7)],
vdims=['y', 'perr', 'nerr',
'alpha']).options(line_alpha='alpha')
plot = bokeh_renderer.get_plot(errorbars)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
self.assertEqual(cds.data['line_alpha'], np.array([0, 0.2, 0.7]))
self.assertEqual(glyph.line_alpha, {'field': 'line_alpha'})
def test_errorbars_color_op(self):
errorbars = ErrorBars([(0, 0, 0.1, 0.2, '#000'),
(0, 1, 0.2, 0.4, '#F00'),
(0, 2, 0.6, 1.2, '#0F0')],
vdims=['y', 'perr', 'nerr',
'color']).options(color='color')
plot = bokeh_renderer.get_plot(errorbars)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
self.assertEqual(cds.data['color'], np.array(['#000', '#F00', '#0F0']))
self.assertEqual(glyph.line_color, {'field': 'color'})
def test_complex_range_example(self):
errors = [(0.1*i, np.sin(0.1*i), (i+1)/3., (i+1)/5.) for i in np.linspace(0, 100, 11)]
errors = ErrorBars(errors, vdims=['y', 'yerrneg', 'yerrpos']).redim.range(y=(0, None))
overlay = Curve(errors) * errors * VLine(4)
plot = bokeh_renderer.get_plot(overlay)
x_range = plot.handles['x_range']
y_range = plot.handles['y_range']
self.assertEqual(x_range.start, 0)
self.assertEqual(x_range.end, 10.0)
self.assertEqual(y_range.start, 0)
self.assertEqual(y_range.end, 19.655978889110628)
def test_points_errorbars_text_ndoverlay_categorical_xaxis_invert_axes(self):
overlay = NdOverlay({i: Points(([chr(65+i)]*10,np.random.randn(10)))
for i in range(5)})
error = ErrorBars([(el['x'][0], np.mean(el['y']), np.std(el['y']))
for el in overlay]).opts(plot=dict(invert_axes=True))
text = Text('C', 0, 'Test')
plot = bokeh_renderer.get_plot(overlay*error*text)
x_range = plot.handles['x_range']
y_range = plot.handles['y_range']
self.assertIsInstance(x_range, Range1d)
self.assertIsInstance(y_range, FactorRange)
self.assertEqual(y_range.factors, ['A', 'B', 'C', 'D', 'E'])
def test_points_errorbars_text_ndoverlay_categorical_xaxis(self):
overlay = NdOverlay({i: Points(([chr(65+i)]*10,np.random.randn(10)))
for i in range(5)})
error = ErrorBars([(el['x'][0], np.mean(el['y']), np.std(el['y']))
for el in overlay])
text = Text('C', 0, 'Test')
plot = bokeh_renderer.get_plot(overlay*error*text)
x_range = plot.handles['x_range']
y_range = plot.handles['y_range']
self.assertIsInstance(x_range, FactorRange)
factors = ['A', 'B', 'C', 'D', 'E']
self.assertEqual(x_range.factors, ['A', 'B', 'C', 'D', 'E'])
self.assertIsInstance(y_range, Range1d)
error_plot = plot.subplots[('ErrorBars', 'I')]
for xs, factor in zip(error_plot.handles['source'].data['base'], factors):
self.assertEqual(factor, xs)
def test_errorbars_categorical_color_op(self):
errorbars = ErrorBars([(0, 0, 0.1, 0.2, 'A'), (0, 1, 0.2, 0.4, 'B'),
(0, 2, 0.6, 1.2, 'C')],
vdims=['y', 'perr', 'nerr',
'color']).options(color='color')
plot = bokeh_renderer.get_plot(errorbars)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
cmapper = plot.handles['color_color_mapper']
self.assertTrue(cmapper, CategoricalColorMapper)
self.assertEqual(cmapper.factors, ['A', 'B', 'C'])
self.assertEqual(cds.data['color'], np.array(['A', 'B', 'C']))
self.assertEqual(glyph.line_color, {
'field': 'color',
'transform': cmapper
})
def test_errorbars_linear_color_op(self):
errorbars = ErrorBars([(0, 0, 0.1, 0.2, 0), (0, 1, 0.2, 0.4, 1),
(0, 2, 0.6, 1.2, 2)],
vdims=['y', 'perr', 'nerr',
'color']).options(color='color')
plot = bokeh_renderer.get_plot(errorbars)
cds = plot.handles['cds']
glyph = plot.handles['glyph']
cmapper = plot.handles['color_color_mapper']
self.assertTrue(cmapper, LinearColorMapper)
self.assertEqual(cmapper.low, 0)
self.assertEqual(cmapper.high, 2)
self.assertEqual(cds.data['color'], np.array([0, 1, 2]))
self.assertEqual(glyph.line_color, {
'field': 'color',
'transform': cmapper
})
def test_errorbar_test(self):
errorbars = ErrorBars(([0, 1], [1, 2], [0.1, 0.2]))
plot = mpl_renderer.get_plot(errorbars)
plot.initialize_plot()
def test_visible(self):
element = ErrorBars([(0, 1, 0.5), (1, 2, 1), (2, 3, 2.25)],
vdims=['y', 'y2']).options(visible=False)
state = self._get_plot_state(element)
self.assertEqual(state['data'][0]['visible'], False)
def test_errorbars_alpha_op(self):
errorbars = ErrorBars([(0, 0, 0), (0, 1, 0.2), (0, 2, 0.7)],
vdims=['y', 'alpha']).options(alpha='alpha')
with self.assertRaises(Exception):
mpl_renderer.get_plot(errorbars)
