def test_polygons_no_holes_with_draw_tool(self):
if bokeh_version < '1.0':
raise SkipTest(
'Plotting Polygons with holes requires bokeh >= 1.0')
from bokeh.models import Patches
xs = [1, 2, 3, np.nan, 6, 7, 3]
ys = [2, 0, 7, np.nan, 7, 5, 2]
holes = [[[(1.5, 2), (2, 3), (1.6, 1.6)],
[(2.1, 4.5), (2.5, 5), (2.3, 3.5)]], []]
poly = HoloMap({
0: Polygons([{
'x': xs,
'y': ys,
'holes': holes
}]),
1: Polygons([{
'x': xs,
'y': ys
}])
})
PolyDraw(source=poly)
plot = bokeh_renderer.get_plot(poly)
glyph = plot.handles['glyph']
self.assertFalse(plot._has_holes)
self.assertIsInstance(glyph, Patches)
def test_holomap_dropdown_default(self):
dim = Dimension('X', default='C')
hmap = HoloMap({chr(65+i): Curve([1, 2, 3]) for i in range(10)}, dim)
widgets = bokeh_renderer.get_widget(hmap, 'widgets')
widgets, dimensions, init_dim_vals = widgets.get_widgets()
self.assertEqual(widgets[0]['default'], '2')
self.assertEqual(init_dim_vals, "['C']")
def test_holomap_slider_and_dropdown(self):
hmap = HoloMap({(i, chr(65+i)): Curve([1, 2, 3]) for i in range(10)}, ['X', 'Y'])
widgets = bokeh_renderer.get_widget(hmap, 'widgets')
widgets, dimensions, init_dim_vals = widgets.get_widgets()
self.assertEqual(len(widgets), 2)
slider = widgets[0]
self.assertEqual(slider['type'], 'slider')
self.assertEqual(slider['dim'], 'X')
self.assertEqual(slider['dim_idx'], 0)
self.assertEqual(slider['vals'], repr([repr(float(v)) for v in range(10)]))
self.assertEqual(slider['labels'], repr([str(v) for v in range(10)]))
self.assertEqual(slider['step'], 1)
self.assertEqual(slider['default'], 0)
self.assertEqual(slider['next_dim'], Dimension('Y'))
self.assertEqual(eval(slider['next_vals']),
{str(float(i)): [chr(65+i)] for i in range(10)})
dropdown = widgets[1]
self.assertEqual(dropdown['type'], 'dropdown')
self.assertEqual(dropdown['dim'], 'Y')
self.assertEqual(dropdown['dim_idx'], 1)
self.assertEqual(dropdown['vals'], repr([chr(65+v) for v in range(10)]))
self.assertEqual(dropdown['labels'], repr([chr(65+v) for v in range(10)]))
self.assertEqual(dropdown['step'], 1)
self.assertEqual(dropdown['default'], 0)
self.assertIs(dropdown['next_dim'], None)
self.assertEqual(dimensions, ['X', 'Y'])
self.assertEqual(init_dim_vals, repr(['0.0', 'A']))
def test_holomap_slider_default(self):
dim = Dimension('X', default=3)
hmap = HoloMap({i: Curve([1, 2, 3]) for i in range(1, 9)}, dim)
widgets = bokeh_renderer.get_widget(hmap, 'widgets')
widgets, dimensions, init_dim_vals = widgets.get_widgets()
self.assertEqual(widgets[0]['default'], '2')
self.assertEqual(init_dim_vals, "['3.0']")
def test_holomap_cftime_slider(self):
try:
import cftime
except:
raise SkipTest('Test requires cftime library')
dates = [
cftime.DatetimeGregorian(2000, 2, 28),
cftime.DatetimeGregorian(2000, 3, 1),
cftime.DatetimeGregorian(2000, 3, 2)
]
hmap = HoloMap({d: Curve([1, 2, i])
for i, d in enumerate(dates)}, 'Date')
widgets = bokeh_renderer.get_widget(hmap, 'widgets')
widgets, dimensions, init_dim_vals = widgets.get_widgets()
self.assertEqual(len(widgets), 1)
slider = widgets[0]
self.assertEqual(slider['type'], 'slider')
self.assertEqual(slider['dim'], 'Date')
self.assertEqual(slider['dim_idx'], 0)
self.assertEqual(slider['vals'], repr([str(d) for d in dates]))
self.assertEqual(slider['labels'], repr([str(d) for d in dates]))
self.assertEqual(slider['step'], 1)
self.assertEqual(slider['default'], 0)
self.assertIs(slider['next_dim'], None)
self.assertEqual(dimensions, ['Date'])
self.assertEqual(init_dim_vals, ['2000-02-28 00:00:00'])
def test_layout_update_visible(self):
hmap = HoloMap(
{i: Curve(np.arange(i), label='A')
for i in range(1, 3)})
hmap2 = HoloMap(
{i: Curve(np.arange(i), label='B')
for i in range(3, 5)})
plot = bokeh_renderer.get_plot(hmap + hmap2)
subplot1, subplot2 = [p for k, p in sorted(plot.subplots.items())]
subplot1 = subplot1.subplots['main']
subplot2 = subplot2.subplots['main']
self.assertTrue(subplot1.handles['glyph_renderer'].visible)
self.assertFalse(subplot2.handles['glyph_renderer'].visible)
plot.update((4, ))
self.assertFalse(subplot1.handles['glyph_renderer'].visible)
self.assertTrue(subplot2.handles['glyph_renderer'].visible)
def test_hover_tooltip_update(self):
hmap = HoloMap({'a': Curve([1, 2, 3], vdims='a'), 'b': Curve([1, 2, 3], vdims='b')}).opts(
tools=['hover'])
plot = bokeh_renderer.get_plot(hmap)
self.assertEqual(plot.handles['hover'].tooltips, [('x', '@{x}'), ('a', '@{a}')])
plot.update(('b',))
self.assertEqual(plot.handles['hover'].tooltips, [('x', '@{x}'), ('b', '@{b}')])
def test_holomap_datetime_widgets(self):
hmap = HoloMap({
np.datetime64(dt.datetime(2017, 1, i)): Curve([i])
for i in range(1, 3)
})
widgets = mpl_renderer.get_widget(hmap, 'widgets')
key_data = json.loads(widgets.get_key_data())
widget_data, dimensions, init_vals = widgets.get_widgets()
expected = {
'type': 'slider',
'vals':
"['2017-01-01T00:00:00.000000000', '2017-01-02T00:00:00.000000000']",
'labels':
"['2017-01-01T00:00:00.000000000', '2017-01-02T00:00:00.000000000']",
'step': 1,
'default': 0,
'next_vals': '{}',
'next_dim': None,
'init_val': '2017-01-01T00:00:00.000000000',
'visible': True,
'dim': 'Default',
'dim_label': 'Default',
'dim_idx': 0,
'visibility': '',
'value': np.datetime64(dt.datetime(2017, 1, 1))
}
self.assertEqual(widget_data[0], expected)
expected_keys = {
"('2017-01-01T00:00:00.000000000',)": 0,
"('2017-01-02T00:00:00.000000000',)": 1
}
self.assertEqual(key_data, expected_keys)
def test_batched_empty_update_invisible(self):
hmap = HoloMap({i: NdOverlay({j: Curve(np.arange(i), label='A') for j in range(i%2)})
for i in range(1, 4)})
opts = {'NdOverlay': {'legend_limit': 0}}
plot = list(bokeh_renderer.get_plot(hmap(plot=opts)).subplots.values())[0]
self.assertTrue(plot.handles['glyph_renderer'].visible)
plot.update((2,))
self.assertFalse(plot.handles['glyph_renderer'].visible)
def test_grid_title(self):
grid = GridSpace({(i, j): HoloMap({a: Image(np.random.rand(10,10))
for a in range(3)}, kdims=['X'])
for i in range(2) for j in range(3)})
plot = bokeh_renderer.get_plot(grid)
title = plot.handles['title']
self.assertIsInstance(title, Div)
text = "<span style='font-size: 16pt'><b>X: 0</b></font>"
self.assertEqual(title.text, text)
def test_overlay_update_plot_opts_inherited(self):
hmap = HoloMap({
0: (Curve([]).options(title='A') * Curve([])),
1: (Curve([]).options(title='B') * Curve([]))
})
plot = mpl_renderer.get_plot(hmap)
self.assertEqual(plot.handles['title'].get_text(), 'A')
plot.update((1, ))
self.assertEqual(plot.handles['title'].get_text(), 'B')
def test_overlay_update_plot_opts_inherited(self):
hmap = HoloMap(
{0: (Curve([]).options(title='A') * Curve([])),
1: (Curve([]).options(title='B') * Curve([]))}
)
plot = bokeh_renderer.get_plot(hmap)
self.assertEqual(plot.state.title.text, 'A')
plot.update((1,))
self.assertEqual(plot.state.title.text, 'B')
def test_holomap_slider_unsorted_initialization(self):
data = [(3, Curve([3, 2, 1])), (1, Curve([1, 2, 3]))]
hmap = HoloMap(data, ['X'], sort=False)
widgets = bokeh_renderer.get_widget(hmap, 'widgets')
widgets, dimensions, init_dim_vals = widgets.get_widgets()
self.assertEqual(len(widgets), 1)
slider = widgets[0]
self.assertEqual(slider['vals'], "['1.0', '3.0']")
self.assertEqual(slider['labels'], "['1', '3']")
def test_overlay_update_sources(self):
hmap = HoloMap({i: (Curve(np.arange(i), label='A') *
Curve(np.arange(i)*2, label='B'))
for i in range(10, 13)})
plot = bokeh_renderer.get_plot(hmap)
plot.update((12,))
subplot1, subplot2 = plot.subplots.values()
self.assertEqual(subplot1.handles['source'].data['y'], np.arange(12))
self.assertEqual(subplot2.handles['source'].data['y'], np.arange(12)*2)
def test_holomap_slider_unsorted_datetime_values_initialization(self):
hmap = HoloMap([(np.datetime64(10005, 'D'), Curve([1, 2, 3])),
(np.datetime64(10000, 'D'), Curve([1, 2, 4]))],
sort=False)
widgets = plotly_renderer.get_widget(hmap, 'widgets')
widgets()
self.assertEqual(widgets.plot.current_key,
(np.datetime64(10000, 'D'), ))
self.assertEqual(widgets.plot.current_frame,
hmap[np.datetime64(10000, 'D')])
def test_holomap_slider_unsorted(self):
data = {(i, j): Curve([1, 2, 3]) for i in range(3) for j in range(3)}
del data[2, 2]
hmap = HoloMap(data, ['X', 'Y'])
widgets = bokeh_renderer.get_widget(hmap, 'widgets')
widgets, dimensions, init_dim_vals = widgets.get_widgets()
self.assertEqual(len(widgets), 2)
slider = widgets[1]
self.assertEqual(slider['vals'], repr([repr(float(v)) for v in range(3)]))
self.assertEqual(slider['labels'], repr([str(v) for v in range(3)]))
def setUp(self):
self.img_fn = lambda: Image(np.random.rand(10, 10))
self.contour_fn = lambda: Contours([np.random.rand(10, 2)
for i in range(2)])
params = [list(range(3)) for i in range(2)]
self.img_map = HoloMap({(i, j): self.img_fn()
for i, j in product(*params)},
key_dimensions=['a', 'b'])
self.contour_map = HoloMap({(i, j): self.contour_fn()
for i, j in product(*params)},
key_dimensions=['a', 'b'])
self.ndoverlay_map = self.img_map.overlay('b')
self.overlay_map = self.img_map * self.contour_map
self.layout_map = self.ndoverlay_map + self.contour_map
self.duplicate_map = self.img_map.clone(key_dimensions=['x', 'y'])
self.overlap1 = HoloMap({i: self.img_fn() for i in range(5)})
self.overlap2 = HoloMap({i: self.img_fn() for i in range(10)})
self.overlap_layout = self.overlap1 + self.overlap2
def test_holomap_legend_updates_varying_lengths(self):
hmap = HoloMap({i: Overlay([Curve([1, 2, j], label=chr(65+j)) for j in range(i)]) for i in range(1, 4)})
plot = bokeh_renderer.get_plot(hmap)
legend_labels = [item.label for item in plot.state.legend[0].items]
self.assertEqual(legend_labels, [{'value': 'A'}])
plot.update((2,))
legend_labels = [item.label for item in plot.state.legend[0].items]
self.assertEqual(legend_labels, [{'value': 'A'}, {'value': 'B'}])
plot.update((3,))
legend_labels = [item.label for item in plot.state.legend[0].items]
self.assertEqual(legend_labels, [{'value': 'A'}, {'value': 'B'}, {'value': 'C'}])
def test_cyclic_palette_curves(self):
palette = Palette('Set1')
opts = dict(color=palette)
hmap = HoloMap({i: NdOverlay({j: Curve(np.random.rand(3)).opts(style=opts)
for j in range(3)})
for i in range(3)})
colors = palette[3].values
plot = bokeh_renderer.get_plot(hmap)
for subp, color in zip(plot.subplots.values(), colors):
color = color if isinstance(color, basestring) else rgb2hex(color)
self.assertEqual(subp.handles['glyph'].line_color, color)
def test_holomap_legend_updates(self):
hmap = HoloMap({i: Curve([1, 2, 3], label=chr(65+i+2)) * Curve([1, 2, 3], label='B')
for i in range(3)})
plot = bokeh_renderer.get_plot(hmap)
legend_labels = [item.label for item in plot.state.legend[0].items]
self.assertEqual(legend_labels, [{'value': 'C'}, {'value': 'B'}])
plot.update((1,))
legend_labels = [item.label for item in plot.state.legend[0].items]
self.assertEqual(legend_labels, [{'value': 'B'}, {'value': 'D'}])
plot.update((2,))
legend_labels = [item.label for item in plot.state.legend[0].items]
self.assertEqual(legend_labels, [{'value': 'B'}, {'value': 'E'}])
def setUp(self):
alphas, betas, deltas = 2, 2, 2
Bs = list(range(100))
coords = itertools.product(*(range(n) for n in [alphas, betas, deltas]))
mus=np.random.rand(alphas, betas, 100, 10)
self.phase_boundaries = {(a, b, d): Curve(zip(Bs, mus[a, b, :, i]*a+b))
for i in range(10) for a, b, d in coords}
self.dimensions = ['alpha', 'beta', 'delta']
self.nesting_hmap = HoloMap(self.phase_boundaries, kdims=self.dimensions)
self.nested_hmap = self.nesting_hmap.groupby(['alpha'])
self.nested_overlay = self.nesting_hmap.overlay(['delta'])
self.nested_grid = self.nested_overlay.grid(['alpha', 'beta'])
self.nested_layout = self.nested_overlay.layout(['alpha', 'beta'])
def test_polygons_holes_initialize(self):
from bokeh.models import MultiPolygons
xs = [1, 2, 3, np.nan, 6, 7, 3]
ys = [2, 0, 7, np.nan, 7, 5, 2]
holes = [
[[(1.5, 2), (2, 3), (1.6, 1.6)], [(2.1, 4.5), (2.5, 5), (2.3, 3.5)]],
[]
]
poly = HoloMap({0: Polygons([{'x': xs, 'y': ys, 'holes': holes}]),
1: Polygons([{'x': xs, 'y': ys}])})
plot = bokeh_renderer.get_plot(poly)
glyph = plot.handles['glyph']
self.assertTrue(plot._has_holes)
self.assertIsInstance(glyph, MultiPolygons)
def test_grid_title(self):
grid = GridSpace({
(i, j):
HoloMap({a: Image(np.random.rand(10, 10))
for a in range(3)},
kdims=['X'])
for i in range(2) for j in range(3)
})
plot = bokeh_renderer.get_plot(grid)
title = plot.handles['title']
self.assertIsInstance(title, Div)
text = ('<span style="color:black;font-family:Arial;'
'font-style:bold;font-weight:bold;font-size:16pt">X: 0</span>')
self.assertEqual(title.text, text)
def test_holomap_slider(self):
hmap = HoloMap({i: Curve([1, 2, 3]) for i in range(10)}, 'X')
widgets = bokeh_renderer.get_widget(hmap, 'widgets')
widgets, dimensions, init_dim_vals = widgets.get_widgets()
self.assertEqual(len(widgets), 1)
slider = widgets[0]
self.assertEqual(slider['type'], 'slider')
self.assertEqual(slider['dim'], 'X')
self.assertEqual(slider['dim_idx'], 0)
self.assertEqual(slider['vals'], repr([repr(float(v)) for v in range(10)]))
self.assertEqual(slider['labels'], repr([str(v) for v in range(10)]))
self.assertEqual(slider['step'], 1)
self.assertEqual(slider['default'], 0)
self.assertIs(slider['next_dim'], None)
self.assertEqual(dimensions, ['X'])
self.assertEqual(init_dim_vals, repr(['0.0']))
def test_holomap_dropdown(self):
hmap = HoloMap({chr(65+i): Curve([1, 2, 3]) for i in range(10)}, 'X')
widgets = bokeh_renderer.get_widget(hmap, 'widgets')
widgets, dimensions, init_dim_vals = widgets.get_widgets()
self.assertEqual(len(widgets), 1)
dropdown = widgets[0]
self.assertEqual(dropdown['type'], 'dropdown')
self.assertEqual(dropdown['dim'], 'X')
self.assertEqual(dropdown['dim_idx'], 0)
self.assertEqual(dropdown['vals'], repr([chr(65+v) for v in range(10)]))
self.assertEqual(dropdown['labels'], repr([chr(65+v) for v in range(10)]))
self.assertEqual(dropdown['step'], 1)
self.assertEqual(dropdown['default'], 0)
self.assertIs(dropdown['next_dim'], None)
self.assertEqual(dimensions, ['X'])
self.assertEqual(init_dim_vals, repr(['A']))
def test_grid_shared_source_synced_update(self):
hmap = HoloMap({
i: Dataset({chr(65 + j): np.random.rand(i + 2)
for j in range(4)},
kdims=['A', 'B', 'C', 'D'])
for i in range(3)
})
# Create two holomaps of points sharing the same data source
hmap1 = hmap.map(lambda x: Points(x.clone(kdims=['A', 'B'])), Dataset)
hmap2 = hmap.map(lambda x: Points(x.clone(kdims=['D', 'C'])), Dataset)
# Pop key (1,) for one of the HoloMaps and make GridSpace
hmap2.pop(1)
grid = GridSpace({
0: hmap1,
2: hmap2
}, kdims=['X']).opts(plot=dict(shared_datasource=True))
# Get plot
plot = bokeh_renderer.get_plot(grid)
# Check plot created shared data source and recorded expected columns
sources = plot.handles.get('shared_sources', [])
source_cols = plot.handles.get('source_cols', {})
self.assertEqual(len(sources), 1)
source = sources[0]
data = source.data
cols = source_cols[id(source)]
self.assertEqual(set(cols), {'A', 'B', 'C', 'D'})
# Ensure the source contains the expected columns
self.assertEqual(set(data.keys()), {'A', 'B', 'C', 'D'})
# Update to key (1,) and check the source contains data
# corresponding to hmap1 and filled in NaNs for hmap2,
# which was popped above
plot.update((1, ))
self.assertEqual(data['A'], hmap1[1].dimension_values(0))
self.assertEqual(data['B'], hmap1[1].dimension_values(1))
self.assertEqual(data['C'],
np.full_like(hmap1[1].dimension_values(0), np.NaN))
self.assertEqual(data['D'],
np.full_like(hmap1[1].dimension_values(0), np.NaN))
def test_contours_linear_color_op_update(self):
contours = HoloMap({
0: Contours([
{('x', 'y'): [(0, 0), (0, 1), (1, 0)], 'color': 7},
{('x', 'y'): [(1, 0), (1, 1), (0, 1)], 'color': 3}
], vdims='color'),
1: Contours([
{('x', 'y'): [(0, 0), (0, 1), (1, 0)], 'color': 5},
{('x', 'y'): [(1, 0), (1, 1), (0, 1)], 'color': 2}
], vdims='color')}).options(color='color', framewise=True)
plot = bokeh_renderer.get_plot(contours)
cds = plot.handles['source']
glyph = plot.handles['glyph']
cmapper = plot.handles['color_color_mapper']
self.assertEqual(glyph.line_color, {'field': 'color', 'transform': cmapper})
self.assertEqual(cds.data['color'], np.array([7, 3]))
self.assertEqual(cmapper.low, 3)
self.assertEqual(cmapper.high, 7)
plot.update((1,))
self.assertEqual(cds.data['color'], np.array([5, 2]))
self.assertEqual(cmapper.low, 2)
self.assertEqual(cmapper.high, 5)
def test_layout_title_show_title_false(self):
hmap1 = HoloMap({a: Image(np.random.rand(10,10)) for a in range(3)})
hmap2 = HoloMap({a: Image(np.random.rand(10,10)) for a in range(3)})
layout = Layout([hmap1, hmap2]).opts(plot=dict(show_title=False))
plot = bokeh_renderer.get_plot(layout)
self.assertTrue('title' not in plot.handles)
def test_layout_empty_subplots(self):
layout = Curve(range(10)) + NdOverlay() + HoloMap() + HoloMap({1: Image(np.random.rand(10,10))})
plot = bokeh_renderer.get_plot(layout)
self.assertEqual(len(plot.subplots.values()), 2)
def test_holomap_dropdown_bad_default(self):
dim = Dimension('X', default='Z')
hmap = HoloMap({chr(65 + i): Curve([1, 2, 3]) for i in range(10)}, dim)
with self.assertRaises(ValueError):
bokeh_renderer.get_widget(hmap, 'widgets').get_widgets()
