def test_partial_garbage_collect_does_not_clear_tree(self):
obj = HoloMap({0: TestObj([]), 1: TestObj([])}).opts(style_opt1='A')
obj.pop(0)
gc.collect()
custom_options = Store._custom_options['backend_1']
self.assertIn(obj.last.id, custom_options)
self.assertEqual(len(custom_options), 1)
obj.pop(1)
gc.collect()
self.assertEqual(len(custom_options), 0)
def test_concat_grid_3d_shape_mismatch(self):
arr1 = np.random.rand(3, 2)
arr2 = np.random.rand(2, 3)
ds1 = Dataset(([0, 1], [1, 2, 3], arr1), ['x', 'y'], 'z')
ds2 = Dataset(([0, 1, 2], [1, 2], arr2), ['x', 'y'], 'z')
hmap = HoloMap({1: ds1, 2: ds2})
arr = np.full((3, 3, 2), np.NaN)
arr[:, :2, 0] = arr1
arr[:2, :, 1] = arr2
ds = Dataset(([1, 2], [0, 1, 2], [1, 2, 3], arr), ['Default', 'x', 'y'], 'z')
self.assertEqual(concat(hmap), ds)
def test_spikes_line_width_op_update(self):
spikes = HoloMap({
0: Spikes([(0, 0, 0.5), (0, 1, 3.2), (0, 2, 1.8)],
vdims=['y', 'line_width']),
1: Spikes([(0, 0, 0.1), (0, 1, 0.8), (0, 2, 0.3)],
vdims=['y', 'line_width'])}).options(linewidth='line_width')
plot = mpl_renderer.get_plot(spikes)
artist = plot.handles['artist']
self.assertEqual(artist.get_linewidths(), [0.5, 3.2, 1.8])
plot.update((1,))
self.assertEqual(artist.get_linewidths(), [0.1, 0.8, 0.3])
def test_point_linear_color_op_update(self):
points = HoloMap({0: Points([(0, 0, 0), (0, 1, 1), (0, 2, 2)],
vdims='color'),
1: Points([(0, 0, 2.5), (0, 1, 3), (0, 2, 1.2)],
vdims='color')}).options(color='color', framewise=True)
plot = mpl_renderer.get_plot(points)
artist = plot.handles['artist']
self.assertEqual(artist.get_clim(), (0, 2))
plot.update((1,))
self.assertEqual(artist.get_array(), np.array([2.5, 3, 1.2]))
self.assertEqual(artist.get_clim(), (1.2, 3))
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_chord_edge_color_linear_style_mapping_update(self):
hmap = HoloMap({
0: self.make_chord(0),
1: self.make_chord(1)
}).options(edge_color='weight', framewise=True)
plot = mpl_renderer.get_plot(hmap)
edges = plot.handles['edges']
self.assertEqual(edges.get_array(), np.array([1, 2, 3]))
self.assertEqual(edges.get_clim(), (1, 3))
plot.update((1, ))
self.assertEqual(edges.get_array(), np.array([2, 3, 4]))
self.assertEqual(edges.get_clim(), (2, 4))
def test_graph_op_edge_line_width_update(self):
graph = HoloMap({
0:
Graph([(0, 1, 2), (0, 2, 0.5), (1, 3, 3)], vdims='line_width'),
1:
Graph([(0, 1, 4.3), (0, 2, 1.4), (1, 3, 2.6)], vdims='line_width')
}).options(edge_linewidth='line_width')
plot = mpl_renderer.get_plot(graph)
edges = plot.handles['edges']
self.assertEqual(edges.get_linewidths(), [2, 0.5, 3])
plot.update((1, ))
self.assertEqual(edges.get_linewidths(), [4.3, 1.4, 2.6])
def test_point_size_op_update(self):
points = HoloMap({
0:
Points([(0, 0, 3), (0, 1, 1), (0, 2, 2)], vdims='size'),
1:
Points([(0, 0, 2.5), (0, 1, 3), (0, 2, 1.2)], vdims='size')
}).options(s='size')
plot = mpl_renderer.get_plot(points)
artist = plot.handles['artist']
self.assertEqual(artist.get_sizes(), np.array([3, 1, 2]))
plot.update((1, ))
self.assertEqual(artist.get_sizes(), np.array([2.5, 3, 1.2]))
def test_dataset_groupby_alias(self):
group1 = {'age': [10, 16], 'weight': [15, 18], 'height': [0.8, 0.6]}
group2 = {'age': [12], 'weight': [10], 'height': [0.8]}
grouped = HoloMap([
('M',
Dataset(group1, kdims=[('age', 'Age')], vdims=self.alias_vdims)),
('F',
Dataset(group2, kdims=[('age', 'Age')], vdims=self.alias_vdims))
],
kdims=[('gender', 'Gender')])
self.assertEqual(
self.alias_table.groupby('Gender').apply('sort'), grouped)
def test_point_line_width_op_update(self):
points = HoloMap({
0:
Points([(0, 0, 3), (0, 1, 1), (0, 2, 2)], vdims='line_width'),
1:
Points([(0, 0, 2.5), (0, 1, 3), (0, 2, 1.2)], vdims='line_width')
}).options(linewidth='line_width')
plot = mpl_renderer.get_plot(points)
artist = plot.handles['artist']
self.assertEqual(artist.get_linewidths(), [3, 1, 2])
plot.update((1, ))
self.assertEqual(artist.get_linewidths(), [2.5, 3, 1.2])
def test_label_size_op_update(self):
labels = HoloMap({
0: Labels([(0, 0, 8), (0, 1, 6), (0, 2, 12)],
vdims='size'),
1: Labels([(0, 0, 9), (0, 1, 4), (0, 2, 3)],
vdims='size')}).options(size='size')
plot = mpl_renderer.get_plot(labels)
artist = plot.handles['artist']
self.assertEqual([a.get_fontsize() for a in artist], [8, 6, 12])
plot.update((1,))
artist = plot.handles['artist']
self.assertEqual([a.get_fontsize() for a in artist], [9, 4, 3])
def test_path_continuously_varying_line_width_op_update(self):
xs = [1, 2, 3, 4]
ys = xs[::-1]
path = HoloMap({
0: Path([{'x': xs, 'y': ys, 'line_width': [1, 7, 3, 2]}], vdims='line_width'),
1: Path([{'x': xs, 'y': ys, 'line_width': [3, 8, 2, 3]}], vdims='line_width')
}).options(linewidth='line_width')
plot = mpl_renderer.get_plot(path)
artist = plot.handles['artist']
self.assertEqual(artist.get_linewidths(), [1, 7, 3, 2])
plot.update((1,))
self.assertEqual(artist.get_linewidths(), [3, 8, 2, 3])
def test_spikes_linear_color_op_update(self):
spikes = HoloMap({
0: Spikes([(0, 0, 0.5), (0, 1, 3.2), (0, 2, 1.8)],
vdims=['y', 'color']),
1: Spikes([(0, 0, 0.1), (0, 1, 0.8), (0, 2, 0.3)],
vdims=['y', 'color'])}).options(color='color', framewise=True)
plot = mpl_renderer.get_plot(spikes)
artist = plot.handles['artist']
self.assertEqual(artist.get_array(), np.array([0.5, 3.2, 1.8]))
self.assertEqual(artist.get_clim(), (0.5, 3.2))
plot.update((1,))
self.assertEqual(artist.get_array(), np.array([0.1, 0.8, 0.3]))
self.assertEqual(artist.get_clim(), (0.1, 0.8))
def test_label_rotation_op_update(self):
labels = HoloMap({
0:
Labels([(0, 0, 45), (0, 1, 180), (0, 2, 90)], vdims='rotation'),
1:
Labels([(0, 0, 30), (0, 1, 120), (0, 2, 60)], vdims='rotation')
}).options(rotation='rotation')
plot = mpl_renderer.get_plot(labels)
artist = plot.handles['artist']
self.assertEqual([a.get_rotation() for a in artist], [45, 180, 90])
plot.update((1, ))
artist = plot.handles['artist']
self.assertEqual([a.get_rotation() for a in artist], [30, 120, 60])
def test_chord_edge_color_style_mapping_update(self):
hmap = HoloMap({0: self.make_chord(0), 1: self.make_chord(1)}).options(
edge_color=dim('weight').categorize({1: 'red', 2: 'green', 3: 'blue', 4: 'black'})
)
plot = mpl_renderer.get_plot(hmap)
edges = plot.handles['edges']
self.assertEqual(edges.get_edgecolors(), np.array([
[1, 0, 0, 1], [0, 0.501961, 0, 1], [0, 0, 1, 1]
]))
plot.update((1,))
self.assertEqual(edges.get_edgecolors(), np.array([
[0, 0.501961, 0, 1], [0, 0, 1, 1], [0, 0, 0, 1]
]))
def test_label_alpha_op_update(self):
labels = HoloMap({
0:
Labels([(0, 0, 0.3), (0, 1, 1), (0, 2, 0.6)], vdims='alpha'),
1:
Labels([(0, 0, 0.6), (0, 1, 0.1), (0, 2, 1)], vdims='alpha')
}).options(alpha='alpha')
plot = mpl_renderer.get_plot(labels)
artist = plot.handles['artist']
self.assertEqual([a.get_alpha() for a in artist], [0.3, 1, 0.6])
plot.update((1, ))
artist = plot.handles['artist']
self.assertEqual([a.get_alpha() for a in artist], [0.6, 0.1, 1])
def test_graph_op_edge_color_linear_update(self):
graph = HoloMap({
0: Graph([(0, 1, 2), (0, 2, 0.5), (1, 3, 3)],
vdims='color'),
1: Graph([(0, 1, 4.3), (0, 2, 1.4), (1, 3, 2.6)],
vdims='color')}).options(edge_color='color', framewise=True)
plot = mpl_renderer.get_plot(graph)
edges = plot.handles['edges']
self.assertEqual(edges.get_array(), np.array([2, 0.5, 3]))
self.assertEqual(edges.get_clim(), (0.5, 3))
plot.update((1,))
self.assertEqual(edges.get_array(), np.array([4.3, 1.4, 2.6]))
self.assertEqual(edges.get_clim(), (1.4, 4.3))
def test_chord_node_color_linear_style_mapping_update(self):
hmap = HoloMap({0: self.make_chord(0), 1: self.make_chord(1)}).options(node_color='Label', framewise=True)
plot = mpl_renderer.get_plot(hmap)
arcs = plot.handles['arcs']
nodes = plot.handles['nodes']
self.assertEqual(nodes.get_array(), np.array([0, 1, 2]))
self.assertEqual(arcs.get_array(), np.array([0, 1, 2]))
self.assertEqual(nodes.get_clim(), (0, 2))
self.assertEqual(arcs.get_clim(), (0, 2))
plot.update((1,))
self.assertEqual(nodes.get_array(), np.array([1, 2, 3]))
self.assertEqual(arcs.get_array(), np.array([1, 2, 3]))
self.assertEqual(nodes.get_clim(), (1, 3))
self.assertEqual(arcs.get_clim(), (1, 3))
def test_graph_op_node_size_update(self):
edges = [(0, 1), (0, 2)]
def get_graph(i):
c1, c2, c3 = {0: (2, 4, 6),
1: (12, 3, 5)}[i]
nodes = Nodes([(0, 0, 0, c1), (0, 1, 1, c2), (1, 1, 2, c3)],
vdims='size')
return Graph((edges, nodes))
graph = HoloMap({0: get_graph(0), 1: get_graph(1)}).options(node_size='size')
plot = mpl_renderer.get_plot(graph)
artist = plot.handles['nodes']
self.assertEqual(artist.get_sizes(), np.array([4, 16, 36]))
plot.update((1,))
self.assertEqual(artist.get_sizes(), np.array([144, 9, 25]))
def test_label_color_op_update(self):
labels = HoloMap({
0: Labels([(0, 0, '#000000'), (0, 1, '#FF0000'), (0, 2, '#00FF00')],
vdims='color'),
1: Labels([(0, 0, '#FF0000'), (0, 1, '#00FF00'), (0, 2, '#0000FF')],
vdims='color')}).options(color='color')
plot = mpl_renderer.get_plot(labels)
artist = plot.handles['artist']
self.assertEqual([a.get_color() for a in artist],
['#000000', '#FF0000', '#00FF00'])
plot.update((1,))
artist = plot.handles['artist']
self.assertEqual([a.get_color() for a in artist],
['#FF0000', '#00FF00', '#0000FF'])
def test_point_line_color_op_update(self):
points = HoloMap({
0:
Points([(0, 0, '#000000'), (0, 1, '#FF0000'), (0, 2, '#00FF00')],
vdims='color'),
1:
Points([(0, 0, '#0000FF'), (0, 1, '#00FF00'), (0, 2, '#FF0000')],
vdims='color')
}).options(edgecolors='color')
plot = mpl_renderer.get_plot(points)
artist = plot.handles['artist']
plot.update((1, ))
self.assertEqual(artist.get_edgecolors(),
np.array([[0, 0, 1, 1], [0, 1, 0, 1], [1, 0, 0, 1]]))
def test_groupby_3d_from_xarray(self):
try:
import xarray as xr
except:
raise SkipError("Test requires xarray")
zs = np.arange(40).reshape(2, 4, 5)
da = xr.DataArray(zs, dims=['z', 'y', 'x'],
coords = {'lat': (('y', 'x'), self.ys),
'lon': (('y', 'x'), self.xs),
'z': [0, 1]}, name='A')
grouped = Dataset(da, ['lon', 'lat', 'z'], 'A').groupby('z')
hmap = HoloMap({0: Dataset((self.xs, self.ys, zs[0]), ['lon', 'lat'], 'A'),
1: Dataset((self.xs, self.ys, zs[1]), ['lon', 'lat'], 'A')}, kdims='z')
self.assertEqual(grouped, hmap)
def test_graph_op_node_linewidth_update(self):
edges = [(0, 1), (0, 2)]
def get_graph(i):
c1, c2, c3 = {0: (2, 4, 6),
1: (12, 3, 5)}[i]
nodes = Nodes([(0, 0, 0, c1), (0, 1, 1, c2), (1, 1, 2, c3)],
vdims='line_width')
return Graph((edges, nodes))
graph = HoloMap({0: get_graph(0), 1: get_graph(1)}).options(node_linewidth='line_width')
plot = mpl_renderer.get_plot(graph)
artist = plot.handles['nodes']
self.assertEqual(artist.get_linewidths(), [2, 4, 6])
plot.update((1,))
self.assertEqual(artist.get_linewidths(), [12, 3, 5])
def test_dataset_groupby_second_dim(self):
group1 = {"Gender": ["M"], "Weight": [15], "Height": [0.8]}
group2 = {"Gender": ["M"], "Weight": [18], "Height": [0.6]}
group3 = {"Gender": ["F"], "Weight": [10], "Height": [0.8]}
grouped = HoloMap(
[
(10, Dataset(group1, kdims=["Gender"], vdims=self.vdims)),
(16, Dataset(group2, kdims=["Gender"], vdims=self.vdims)),
(12, Dataset(group3, kdims=["Gender"], vdims=self.vdims)),
],
kdims=["Age"],
sort=True,
)
self.assertEqual(self.table.groupby(["Age"]), grouped)
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_vectorfield_line_width_op_update(self):
vectorfield = HoloMap({
0:
VectorField([(0, 0, 0, 1, 1), (0, 1, 0, 1, 4), (0, 2, 0, 1, 8)],
vdims=['A', 'M', 'line_width']),
1:
VectorField([(0, 0, 0, 1, 3), (0, 1, 0, 1, 2), (0, 2, 0, 1, 5)],
vdims=['A', 'M', 'line_width'])
}).options(linewidth='line_width')
plot = mpl_renderer.get_plot(vectorfield)
artist = plot.handles['artist']
self.assertEqual(artist.get_linewidths(), [1, 4, 8])
plot.update((1, ))
self.assertEqual(artist.get_linewidths(), [3, 2, 5])
def test_spikes_color_op_update(self):
spikes = HoloMap({
0: Spikes([(0, 0, '#000000'), (0, 1, '#FF0000'), (0, 2, '#00FF00')],
vdims=['y', 'color']),
1: Spikes([(0, 0, '#FF0000'), (0, 1, '#00FF00'), (0, 2, '#0000FF')],
vdims=['y', 'color'])}).options(color='color')
plot = mpl_renderer.get_plot(spikes)
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_partial_garbage_collect_does_not_clear_tree(self):
obj = HoloMap({0: TestObj([]), 1: TestObj([])}).opts(style_opt1='A')
obj.pop(0)
gc.collect()
custom_options = Store._custom_options['backend_1']
self.assertIn(obj.last.id, custom_options)
self.assertEqual(len(custom_options), 1)
obj.pop(1)
gc.collect()
self.assertEqual(len(custom_options), 0)
def test_graph_op_node_color_linear_update(self):
edges = [(0, 1), (0, 2)]
def get_graph(i):
c1, c2, c3 = {0: (0.5, 1.5, 2.5),
1: (3, 2, 1)}[i]
nodes = Nodes([(0, 0, 0, c1), (0, 1, 1, c2), (1, 1, 2, c3)],
vdims='color')
return Graph((edges, nodes))
graph = HoloMap({0: get_graph(0), 1: get_graph(1)}).options(node_color='color', framewise=True)
plot = mpl_renderer.get_plot(graph)
artist = plot.handles['nodes']
self.assertEqual(artist.get_array(), np.array([0.5, 1.5, 2.5]))
self.assertEqual(artist.get_clim(), (0.5, 2.5))
plot.update((1,))
self.assertEqual(artist.get_array(), np.array([3, 2, 1]))
self.assertEqual(artist.get_clim(), (1, 3))
def test_dataset_groupby_alias(self):
group1 = {"age": [10, 16], "weight": [15, 18], "height": [0.8, 0.6]}
group2 = {"age": [12], "weight": [10], "height": [0.8]}
grouped = HoloMap(
[
("M",
Dataset(
group1, kdims=[("age", "Age")], vdims=self.alias_vdims)),
("F",
Dataset(
group2, kdims=[("age", "Age")], vdims=self.alias_vdims)),
],
kdims=[("gender", "Gender")],
)
self.assertEqual(
self.alias_table.groupby("Gender").apply("sort"), grouped)
def test_vectorfield_linear_color_op_update(self):
vectorfield = HoloMap({
0:
VectorField([(0, 0, 0, 1, 0), (0, 1, 0, 1, 1), (0, 2, 0, 1, 2)],
vdims=['A', 'M', 'color']),
1:
VectorField([(0, 0, 0, 1, 3.2), (0, 1, 0, 1, 2), (0, 2, 0, 1, 4)],
vdims=['A', 'M', 'color'])
}).options(color='color', framewise=True)
plot = mpl_renderer.get_plot(vectorfield)
artist = plot.handles['artist']
self.assertEqual(np.asarray(artist.get_array()), np.array([0, 1, 2]))
self.assertEqual(artist.get_clim(), (0, 2))
plot.update((1, ))
self.assertEqual(np.asarray(artist.get_array()), np.array([3.2, 2, 4]))
self.assertEqual(artist.get_clim(), (2, 4))
def test_dynamic_operation_on_hmap(self):
hmap = HoloMap({i: Image(sine_array(0,i)) for i in range(10)})
dmap = Dynamic(hmap, operation=lambda x: x)
self.assertEqual(dmap.kdims[0].name, hmap.kdims[0].name)
self.assertEqual(dmap.kdims[0].values, hmap.keys())
def test_heatmap_holomap(self):
hm = HoloMap({'A': HeatMap(np.random.randint(0, 10, (100, 3))),
'B': HeatMap(np.random.randint(0, 10, (100, 3)))})
plot = bokeh_renderer.get_plot(hm.options(radial=True))
self.assertIsInstance(plot, RadialHeatMapPlot)
