def test_violin_simple(self):
values = np.random.rand(100)
violin = Violin(values).opts(plot=dict(violin_width=0.7))
qmin, q1, q2, q3, qmax = (np.percentile(values, q=q)
for q in range(0, 125, 25))
iqr = q3 - q1
upper = min(q3 + 1.5 * iqr, np.nanmax(values))
lower = max(q1 - 1.5 * iqr, np.nanmin(values))
r1, r2 = violin.range(0)
kde = univariate_kde(violin, cut=5)
xs, ys = (kde.dimension_values(i) for i in range(2))
ys = (ys / ys.max()) * (0.7 / 2.)
ys = [('', ) + (sign * y, ) for sign, vs in ((-1, ys), (1, ys[::-1]))
for y in vs]
kde = {'x': np.concatenate([xs, xs[::-1]]), 'y': ys}
plot = bokeh_renderer.get_plot(violin)
self.assertEqual(plot.handles['x_range'].factors, [''])
self.assertEqual(plot.handles['y_range'].start, r1)
self.assertEqual(plot.handles['y_range'].end, r2)
self.assertIn('scatter_1_glyph_renderer', plot.handles)
self.assertIn('vbar_1_glyph_renderer', plot.handles)
seg_source = plot.handles['segment_1_source']
self.assertEqual(seg_source.data['x'], [('', 0)])
self.assertEqual(seg_source.data['y0'], [lower])
self.assertEqual(seg_source.data['y1'], [upper])
scatter_source = plot.handles['scatter_1_source']
self.assertEqual(scatter_source.data['x'], [('', 0)])
self.assertEqual(scatter_source.data['y'], [q2])
patch_source = plot.handles['patches_1_source']
self.assertEqual(patch_source.data['xs'], [kde['y']])
self.assertEqual(patch_source.data['ys'], [kde['x']])
def test_violin_simple(self):
values = np.random.rand(100)
violin = Violin(values).opts(plot=dict(violin_width=0.7))
qmin, q1, q2, q3, qmax = (np.percentile(values, q=q)
for q in range(0,125,25))
iqr = q3 - q1
upper = min(q3 + 1.5*iqr, np.nanmax(values))
lower = max(q1 - 1.5*iqr, np.nanmin(values))
r1, r2 = violin.range(0)
kde = univariate_kde(violin, cut=5)
xs, ys = (kde.dimension_values(i) for i in range(2))
ys = (ys/ys.max())*(0.7/2.)
ys = [('',)+(sign*y,) for sign, vs in ((-1, ys), (1, ys[::-1])) for y in vs]
kde = {'x': np.concatenate([xs, xs[::-1]]), 'y': ys}
plot = bokeh_renderer.get_plot(violin)
self.assertEqual(plot.handles['x_range'].factors, [''])
self.assertEqual(plot.handles['y_range'].start, r1)
self.assertEqual(plot.handles['y_range'].end, r2)
self.assertIn('scatter_1_glyph_renderer', plot.handles)
self.assertIn('vbar_1_glyph_renderer', plot.handles)
seg_source = plot.handles['segment_1_source']
self.assertEqual(seg_source.data['x'], [('', 0)])
self.assertEqual(seg_source.data['y0'], [lower])
self.assertEqual(seg_source.data['y1'], [upper])
scatter_source = plot.handles['scatter_1_source']
self.assertEqual(scatter_source.data['x'], [('', 0)])
self.assertEqual(scatter_source.data['y'], [q2])
patch_source = plot.handles['patches_1_source']
self.assertEqual(patch_source.data['xs'], [kde['y']])
self.assertEqual(patch_source.data['ys'], [kde['x']])
def test_violin_multi(self):
violin = Violin((np.random.randint(0, 2, 100), np.random.rand(100)), kdims=['A']).sort()
r1, r2 = violin.range(1)
plot = mpl_renderer.get_plot(violin)
data, style, axis_opts = plot.get_data(violin, {}, {})
self.assertEqual(data[0][0], violin.select(A=0).dimension_values(1))
self.assertEqual(data[0][1], violin.select(A=1).dimension_values(1))
self.assertEqual(style['positions'], [0, 1])
self.assertEqual(style['labels'], ['0', '1'])
def test_violin_multi(self):
violin = Violin((np.random.randint(0, 2, 100), np.random.rand(100)), kdims=['A']).sort()
r1, r2 = violin.range(1)
plot = mpl_renderer.get_plot(violin)
data, style, axis_opts = plot.get_data(violin, {}, {})
self.assertEqual(data[0][0], violin.select(A=0).dimension_values(1))
self.assertEqual(data[0][1], violin.select(A=1).dimension_values(1))
self.assertEqual(style['positions'], [0, 1])
self.assertEqual(style['labels'], ['0', '1'])
def test_violin_simple_overlay(self):
values = np.random.rand(100)
violin = Violin(values) * Violin(values)
plot = mpl_renderer.get_plot(violin)
p1, p2 = plot.subplots.values()
self.assertEqual(p1.handles['boxes'][0].get_path().vertices,
p2.handles['boxes'][0].get_path().vertices)
for b1, b2 in zip(p1.handles['bodies'][0].get_paths(),
p2.handles['bodies'][0].get_paths()):
self.assertEqual(b1.vertices, b2.vertices)
def test_violin_cats_index_cols(self):
violin = Violin((['A', 'A', 'A', 'B', 'B', 'C', 'C', 'C', 'C', 'C'], list(range(10))), 'x', 'y')
expr, bbox, region = violin._get_selection_expr_for_stream_value(
bounds=(0, 1, 2, 7), x_selection=['A', 'B'], index_cols=['x']
)
self.assertEqual(bbox, {'y': (1, 7), 'x': ['A', 'B']})
self.assertEqual(expr.apply(violin), np.array([
True, True, True, True, True, False, False, False, False, False
]))
self.assertEqual(region, None)
def test_violin_single_inverted(self):
violin = Violin(list(range(10))).opts(invert_axes=True)
expr, bbox, region = violin._get_selection_expr_for_stream_value(
bounds=(3, 0, 7, 1)
)
self.assertEqual(bbox, {'y': (3, 7)})
self.assertEqual(expr.apply(violin), np.array([
False, False, False, True, True, True, True, True, False, False
]))
self.assertEqual(region, NdOverlay({0: VSpan(3, 7)}))
def test_violin_single(self):
violin = Violin(list(range(10)))
expr, bbox, region = violin._get_selection_expr_for_stream_value(
bounds=(0, 3, 1, 7)
)
self.assertEqual(bbox, {'y': (3, 7)})
self.assertEqual(expr.apply(violin), np.array([
False, False, False, True, True, True, True, True, False, False
]))
self.assertEqual(region, NdOverlay({0: HSpan(3, 7)}))
def test_violin_multi_level(self):
box= Violin((['A', 'B']*15, [3, 10, 1]*10, np.random.randn(30)),
['Group', 'Category'], 'Value')
plot = bokeh_renderer.get_plot(box)
x_range = plot.handles['x_range']
self.assertEqual(x_range.factors, [
('A', '1'), ('A', '3'), ('A', '10'), ('B', '1'), ('B', '3'), ('B', '10')])
def test_violin_single_point(self):
data = {'x': [1], 'y': [1]}
violin = Violin(data=data, kdims='x',
vdims='y').opts(plot=dict(inner='box'))
plot = bokeh_renderer.get_plot(violin)
self.assertEqual(plot.handles['x_range'].factors, ['1'])
def test_violin_simple(self):
values = np.random.rand(100)
violin = Violin(values)
plot = mpl_renderer.get_plot(violin)
data, style, axis_opts = plot.get_data(violin, {}, {})
self.assertEqual(data[0][0], values)
self.assertEqual(style['positions'], [0])
self.assertEqual(style['labels'], [''])
def test_violin_box_line_width_op(self):
a = np.repeat(np.arange(5), 5)
b = np.repeat(np.arange(5), 5)
violin = Violin((a, b, np.arange(25)), ['a', 'b'], 'd').options(box_line_width='b')
plot = bokeh_renderer.get_plot(violin)
source = plot.handles['vbar_1_source']
glyph = plot.handles['vbar_1_glyph']
self.assertEqual(source.data['box_line_width'], np.arange(5))
self.assertEqual(glyph.line_width, {'field': 'box_line_width'})
def test_violin_split_op_single(self):
a = np.repeat(np.arange(2), 5)
violin = Violin((a, np.arange(10)), ['a'], 'd').options(split='a')
plot = bokeh_renderer.get_plot(violin)
source = plot.handles['patches_1_source']
glyph = plot.handles['patches_1_glyph']
cmapper = plot.handles['violin_color_mapper']
self.assertEqual(source.data["dim('a')"], ['0', '1'])
self.assertEqual(glyph.fill_color, {'field': "dim('a')", 'transform': cmapper})
def test_violin_alpha_op(self):
a = np.repeat(np.arange(5), 5)
b = np.repeat(np.arange(5)/10., 5)
violin = Violin((a, b, np.arange(25)), ['a', 'b'], 'd').options(violin_alpha='b')
plot = bokeh_renderer.get_plot(violin)
source = plot.handles['patches_1_source']
glyph = plot.handles['patches_1_glyph']
self.assertEqual(source.data['violin_alpha'], np.arange(5)/10.)
self.assertEqual(glyph.fill_alpha, {'field': 'violin_alpha'})
def test_violin_inner_stick(self):
values = np.random.rand(100)
violin = Violin(values).opts(plot=dict(inner='stick'))
kde = univariate_kde(violin, cut=5)
xs = kde.dimension_values(0)
plot = bokeh_renderer.get_plot(violin)
self.assertIn('segment_1_glyph_renderer', plot.handles)
segments = np.array([xs[np.argmin(np.abs(xs - v))] for v in values])
self.assertEqual(plot.handles['segment_1_source'].data['x'], segments)
def test_violin_single(self):
violin = Violin([1, 1, 2, 3, 3, 4, 5, 5])
state = self._get_plot_state(violin)
self.assertEqual(len(state['data']), 1)
self.assertEqual(state['data'][0]['type'], 'violin')
self.assertEqual(state['data'][0]['name'], '')
self.assertEqual(state['data'][0]['y'], np.array([1, 1, 2, 3, 3, 4, 5, 5]))
self.assertEqual(state['layout'].get('xaxis', {}), {})
self.assertEqual(state['layout']['yaxis']['range'], [1, 5])
self.assertEqual(state['layout']['yaxis']['title']['text'], 'y')
def test_violin_split_op_multi(self):
a = np.repeat(np.arange(5), 5)
b = np.repeat(np.arange(5), 5)
violin = Violin((a, b, np.arange(25)), ['a', 'b'], 'd').options(split=dim('b')>2)
plot = bokeh_renderer.get_plot(violin)
source = plot.handles['patches_1_source']
glyph = plot.handles['patches_1_glyph']
cmapper = plot.handles['violin_color_mapper']
self.assertEqual(source.data["dim('b')>2"], ['False', 'False', 'False', 'True', 'True'])
self.assertEqual(glyph.fill_color, {'field': "dim('b')>2", 'transform': cmapper})
def test_violin_inner_quartiles(self):
values = np.random.rand(100)
violin = Violin(values).opts(plot=dict(inner='quartiles'))
kde = univariate_kde(violin, cut=5)
xs = kde.dimension_values(0)
plot = bokeh_renderer.get_plot(violin)
self.assertIn('segment_1_glyph_renderer', plot.handles)
seg_source = plot.handles['segment_1_source']
q1, q2, q3 = (np.percentile(values, q=q) for q in range(25, 100, 25))
y0, y1, y2 = [xs[np.argmin(np.abs(xs - v))] for v in (q1, q2, q3)]
self.assertEqual(seg_source.data['x'], np.array([y0, y1, y2]))
def test_violin_single_invert_axes(self):
violin = Violin([1, 1, 2, 3, 3, 4, 5, 5]).options(invert_axes=True)
state = self._get_plot_state(violin)
self.assertEqual(len(state['data']), 1)
self.assertEqual(state['data'][0]['type'], 'violin')
self.assertEqual(state['data'][0]['name'], '')
self.assertEqual(state['data'][0]['x'],
np.array([1, 1, 2, 3, 3, 4, 5, 5]))
self.assertEqual(state['layout']['yaxis'], {})
self.assertEqual(state['layout']['xaxis']['range'], [1, 5])
self.assertEqual(state['layout']['xaxis']['title'], 'y')
def test_violin_box_categorical_color_op(self):
a = np.repeat(np.arange(5), 5)
b = np.repeat(['A', 'B', 'C', 'D', 'E'], 5)
violin = Violin((a, b, np.arange(25)), ['a', 'b'], 'd').options(box_color='b')
plot = bokeh_renderer.get_plot(violin)
source = plot.handles['vbar_1_source']
glyph = plot.handles['vbar_1_glyph']
cmapper = plot.handles['box_color_color_mapper']
self.assertEqual(source.data['box_color'], b[::5])
self.assertTrue(cmapper, CategoricalColorMapper)
self.assertEqual(cmapper.factors, ['A', 'B', 'C', 'D', 'E'])
self.assertEqual(glyph.fill_color, {'field': 'box_color', 'transform': cmapper})
def test_violin_box_linear_color_op(self):
a = np.repeat(np.arange(5), 5)
b = np.repeat(np.arange(5), 5)
violin = Violin((a, b, np.arange(25)), ['a', 'b'], 'd').options(box_color='b')
plot = bokeh_renderer.get_plot(violin)
source = plot.handles['vbar_1_source']
cmapper = plot.handles['box_color_color_mapper']
glyph = plot.handles['vbar_1_glyph']
self.assertEqual(source.data['box_color'], np.arange(5))
self.assertTrue(cmapper, LinearColorMapper)
self.assertEqual(cmapper.low, 0)
self.assertEqual(cmapper.high, 4)
self.assertEqual(glyph.fill_color, {'field': 'box_color', 'transform': cmapper})
def test_violin_multi(self):
violin = Violin((['A']*8+['B']*8, [1, 1, 2, 3, 3, 4, 5, 5]*2), 'x', 'y')
state = self._get_plot_state(violin)
self.assertEqual(len(state['data']), 2)
self.assertEqual(state['data'][0]['type'], 'violin')
self.assertEqual(state['data'][0]['name'], 'A')
self.assertEqual(state['data'][0]['y'], np.array([1, 1, 2, 3, 3, 4, 5, 5]))
self.assertEqual(state['data'][1]['type'], 'violin')
self.assertEqual(state['data'][1]['name'], 'B')
self.assertEqual(state['data'][1]['y'], np.array([1, 1, 2, 3, 3, 4, 5, 5]))
self.assertEqual(state['layout']['xaxis']['title']['text'], 'x')
self.assertEqual(state['layout']['yaxis']['range'], [1, 5])
self.assertEqual(state['layout']['yaxis']['title']['text'], 'y')
def test_violin_empty(self):
violin = Violin([])
plot = bokeh_renderer.get_plot(violin)
patch_source = plot.handles['patches_1_source']
self.assertEqual(patch_source.data['xs'], [[]])
self.assertEqual(patch_source.data['ys'], [np.array([])])
def test_violin_multi(self):
violin = Violin((np.random.randint(0, 2, 100), np.random.rand(100)),
kdims=['A']).sort()
r1, r2 = violin.range(1)
plot = bokeh_renderer.get_plot(violin)
self.assertEqual(plot.handles['x_range'].factors, ['0', '1'])
def test_visible(self):
element = Violin([1, 1, 2, 3, 3, 4, 5, 5]).options(visible=False)
state = self._get_plot_state(element)
self.assertEqual(state['data'][0]['visible'], False)
def test_violin_multi(self):
violin = Violin((np.random.randint(0, 2, 100), np.random.rand(100)), kdims=['A']).sort()
r1, r2 = violin.range(1)
plot = bokeh_renderer.get_plot(violin)
self.assertEqual(plot.handles['x_range'].factors, ['0', '1'])
