def test_area_with_lower_vdim(self):
area = Area([(1, 0.5, 1), (2, 1.5, 2), (3, 2.5, 3)], vdims=['y', 'y2']).options(padding=0.1)
plot = bokeh_renderer.get_plot(area)
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.25)
self.assertEqual(y_range.end, 3.25)
def test_area_padding_logx(self):
area = Area([(1, 1), (2, 2), (3, 3)]).options(padding=0.1, logx=True)
plot = bokeh_renderer.get_plot(area)
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)
self.assertEqual(y_range.end, 3.2)
def test_area_with_nans(self):
area = Area([1, 2, 3, np.nan, 5, 6, 7])
plot = bokeh_renderer.get_plot(area)
cds = plot.handles['cds']
self.assertEqual(cds.data['x'], np.array([0., 1., 2., 2., 1., 0., np.nan,
4., 5., 6., 6., 5., 4.]))
self.assertEqual(cds.data['y'], np.array([0., 0., 0., 3., 2., 1., np.nan,
0., 0., 0., 7., 6., 5.]))
def test_area_padding_square_per_axis(self):
area = Area([(1, 1), (2, 2), (3, 3)]).options(padding=((0, 0.1), (0.1, 0.2)))
plot = bokeh_renderer.get_plot(area)
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
self.assertEqual(x_range.start, 1.0)
self.assertEqual(x_range.end, 3.2)
self.assertEqual(y_range.start, 0)
self.assertEqual(y_range.end, 3.4)
def test_area_padding_nonsquare(self):
area = Area([(1, 1), (2, 2), (3, 3)]).options(padding=0.1, width=600)
plot = bokeh_renderer.get_plot(area)
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
self.assertEqual(x_range.start, 0.9)
self.assertEqual(x_range.end, 3.1)
self.assertEqual(y_range.start, 0)
self.assertEqual(y_range.end, 3.2)
def test_area_to_zero_y(self):
curve = Area([1, 2, 3])
state = self._get_plot_state(curve)
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]['mode'], 'lines')
self.assertEqual(state['data'][0]['fill'], 'tozeroy')
self.assertEqual(state['layout']['yaxis']['range'], [0, 3])
def test_dynamic_compute_overlayable_zorders_two_dynamic_layers(self):
area = DynamicMap(lambda: Area(range(10)), kdims=[])
dmap = DynamicMap(lambda: Curve(range(10)), kdims=[])
combined = area*dmap
combined[()]
sources = compute_overlayable_zorders(combined)
self.assertEqual(sources[0], [area])
self.assertEqual(sources[1], [dmap])
def test_area_padding_hard_range(self):
area = Area([(1, 1), (2, 2), (3, 3)]).redim.range(y=(0, 4)).options(padding=0.1)
plot = bokeh_renderer.get_plot(area)
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)
self.assertEqual(y_range.end, 4)
def test_area_padding_mixed(self):
area = Area([(1, 1), (2, -2), (3, 3)]).options(padding=0.1)
plot = bokeh_renderer.get_plot(area)
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, -2.5)
self.assertEqual(y_range.end, 3.5)
def test_area_padding_nonsquare(self):
area = Area([(1, 1), (2, 2), (3, 3)]).options(padding=0.1, aspect=2)
plot = mpl_renderer.get_plot(area)
x_range, y_range = plot.handles['axis'].get_xlim(
), plot.handles['axis'].get_ylim()
self.assertEqual(x_range[0], 0.9)
self.assertEqual(x_range[1], 3.1)
self.assertEqual(y_range[0], 0)
self.assertEqual(y_range[1], 3.2)
def test_area_padding_logy(self):
area = Area([(1, 1), (2, 2), (3, 3)]).options(padding=0.1, logy=True)
plot = bokeh_renderer.get_plot(area)
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.033483695221017122)
self.assertEqual(y_range.end, 3.3483695221017129)
self.log_handler.assertContains('WARNING', 'Logarithmic axis range encountered value less than')
def test_area_padding_logx(self):
area = Area([(1, 1), (2, 2), (3, 3)]).options(padding=0.1, logx=True)
plot = mpl_renderer.get_plot(area)
x_range, y_range = plot.handles['axis'].get_xlim(
), plot.handles['axis'].get_ylim()
self.assertEqual(x_range[0], 0.89595845984076228)
self.assertEqual(x_range[1], 3.3483695221017129)
self.assertEqual(y_range[0], 0)
self.assertEqual(y_range[1], 3.2)
def test_area_padding_mixed(self):
area = Area([(1, 1), (2, -2), (3, 3)]).options(padding=0.1)
plot = mpl_renderer.get_plot(area)
x_range, y_range = plot.handles['axis'].get_xlim(
), plot.handles['axis'].get_ylim()
self.assertEqual(x_range[0], 0.8)
self.assertEqual(x_range[1], 3.2)
self.assertEqual(y_range[0], -2.5)
self.assertEqual(y_range[1], 3.5)
def test_area_fill_between_ys(self):
area = Area([(0, 1, 0.5), (1, 2, 1), (2, 3, 2.25)], vdims=['y', 'y2'])
state = self._get_plot_state(area)
self.assertEqual(state['data'][0]['y'], np.array([0.5, 1, 2.25]))
self.assertEqual(state['data'][0]['mode'], 'lines')
self.assertEqual(state['data'][0].get('fill', None), None)
self.assertEqual(state['data'][1]['y'], np.array([1, 2, 3]))
self.assertEqual(state['data'][1]['mode'], 'lines')
self.assertEqual(state['data'][1]['fill'], 'tonexty')
self.assertEqual(state['layout']['yaxis']['range'], [0.5, 3])
def test_area_padding_square_per_axis(self):
area = Area([(1, 1), (2, 2),
(3, 3)]).options(padding=((0, 0.1), (0.1, 0.2)))
plot = mpl_renderer.get_plot(area)
x_range, y_range = plot.handles['axis'].get_xlim(
), plot.handles['axis'].get_ylim()
self.assertEqual(x_range[0], 1)
self.assertEqual(x_range[1], 3.2)
self.assertEqual(y_range[0], 0)
self.assertEqual(y_range[1], 3.4)
def test_area_with_lower_vdim(self):
area = Area([(1, 0.5, 1), (2, 1.5, 2), (3, 2.5, 3)],
vdims=['y', 'y2']).options(padding=0.1)
plot = mpl_renderer.get_plot(area)
x_range, y_range = plot.handles['axis'].get_xlim(
), plot.handles['axis'].get_ylim()
self.assertEqual(x_range[0], 0.8)
self.assertEqual(x_range[1], 3.2)
self.assertEqual(y_range[0], 0.25)
self.assertEqual(y_range[1], 3.25)
def test_area_padding_hard_range(self):
area = Area([(1, 1), (2, 2),
(3, 3)]).redim.range(y=(0, 4)).options(padding=0.1)
plot = mpl_renderer.get_plot(area)
x_range, y_range = plot.handles['axis'].get_xlim(
), plot.handles['axis'].get_ylim()
self.assertEqual(x_range[0], 0.8)
self.assertEqual(x_range[1], 3.2)
self.assertEqual(y_range[0], 0)
self.assertEqual(y_range[1], 4)
def test_area_to_zero_x(self):
curve = Area([1, 2, 3]).options(invert_axes=True)
state = self._get_plot_state(curve)
self.assertEqual(state['data'][0]['x'], np.array([1, 2, 3]))
self.assertEqual(state['data'][0]['y'], np.array([0, 1, 2]))
self.assertEqual(state['data'][0]['mode'], 'lines')
self.assertEqual(state['data'][0]['fill'], 'tozerox')
self.assertEqual(state['layout']['xaxis']['range'], [0, 3])
self.assertEqual(state['layout']['yaxis']['range'], [0, 2])
self.assertEqual(state['layout']['xaxis']['title']['text'], 'y')
self.assertEqual(state['layout']['yaxis']['title']['text'], 'x')
def test_area_padding_logy(self):
area = Area([(1, 1), (2, 2), (3, 3)]).options(padding=0.1, logy=True)
plot = mpl_renderer.get_plot(area)
x_range, y_range = plot.handles['axis'].get_xlim(
), plot.handles['axis'].get_ylim()
self.assertEqual(x_range[0], 0.8)
self.assertEqual(x_range[1], 3.2)
self.assertEqual(y_range[0], 0.03348369522101712)
self.assertEqual(y_range[1], 3.3483695221017129)
self.log_handler.assertContains(
'WARNING', 'Logarithmic axis range encountered value less than')
def test_area_fill_between_xs(self):
area = Area([(0, 1, 0.5), (1, 2, 1), (2, 3, 2.25)],
vdims=['y', 'y2']).options(invert_axes=True)
state = self._get_plot_state(area)
self.assertEqual(state['data'][0]['x'], np.array([0.5, 1, 2.25]))
self.assertEqual(state['data'][0]['mode'], 'lines')
self.assertEqual(state['data'][0]['fill'], None)
self.assertEqual(state['data'][1]['x'], np.array([1, 2, 3]))
self.assertEqual(state['data'][1]['mode'], 'lines')
self.assertEqual(state['data'][1]['fill'], 'tonextx')
self.assertEqual(state['layout']['xaxis']['range'], [0.5, 3])
self.assertEqual(state['layout']['yaxis']['range'], [0, 2])
def test_dynamic_compute_overlayable_zorders_mixed_dynamic_and_non_dynamic_overlays_reverse(self):
area1 = Area(range(10))
area2 = Area(range(10))
overlay = area1 * area2
curve = DynamicMap(lambda: Curve(range(10)), kdims=[])
curve_redim = curve.redim(x='x2')
combined = curve_redim*overlay
combined[()]
sources = compute_overlayable_zorders(combined)
self.assertIn(curve_redim, sources[0])
self.assertIn(curve, sources[0])
self.assertNotIn(overlay, sources[0])
self.assertIn(area1, sources[1])
self.assertIn(overlay, sources[1])
self.assertNotIn(curve_redim, sources[1])
self.assertNotIn(curve, sources[1])
self.assertIn(area2, sources[2])
self.assertIn(overlay, sources[2])
self.assertNotIn(curve_redim, sources[2])
self.assertNotIn(curve, sources[2])
def test_dynamic_compute_overlayable_zorders_three_deep_dynamic_layers_reduced_layers_by_one(
self):
area = DynamicMap(lambda: Area(range(10)), kdims=[])
area2 = DynamicMap(lambda: Area(range(10)), kdims=[])
curve = DynamicMap(lambda: Curve(range(10)), kdims=[])
curve2 = DynamicMap(lambda: Curve(range(10)), kdims=[])
area_redim = area.redim(x='x2')
curve_redim = curve.redim(x='x2')
curve2_redim = curve2.redim(x='x3')
combined = (area_redim * curve_redim * area2).map(
lambda x: x.clone(x.items()[:2]), Overlay)
combined1 = combined * curve2_redim
combined1[()]
sources = compute_overlayable_zorders(combined1)
self.assertNotIn(curve_redim, sources[0])
self.assertNotIn(curve, sources[0])
self.assertNotIn(curve2_redim, sources[0])
self.assertNotIn(curve2, sources[0])
self.assertNotIn(area, sources[0])
self.assertNotIn(area_redim, sources[0])
self.assertNotIn(area2, sources[0])
self.assertNotIn(area_redim, sources[1])
self.assertNotIn(area, sources[1])
self.assertNotIn(curve2_redim, sources[1])
self.assertNotIn(curve2, sources[1])
self.assertNotIn(area2, sources[0])
self.assertIn(curve2_redim, sources[2])
self.assertIn(curve2, sources[2])
self.assertNotIn(area_redim, sources[2])
self.assertNotIn(area, sources[2])
self.assertNotIn(area2, sources[0])
self.assertNotIn(curve_redim, sources[2])
self.assertNotIn(curve, sources[2])
def test_dynamic_compute_overlayable_zorders_two_deep_dynamic_layers(self):
area = DynamicMap(lambda: Area(range(10)), kdims=[])
curve = DynamicMap(lambda: Curve(range(10)), kdims=[])
area_redim = area.redim(x='x2')
curve_redim = curve.redim(x='x2')
combined = area_redim*curve_redim
combined[()]
sources = compute_overlayable_zorders(combined)
self.assertIn(area_redim, sources[0])
self.assertIn(area, sources[0])
self.assertNotIn(curve_redim, sources[0])
self.assertNotIn(curve, sources[0])
self.assertIn(curve_redim, sources[1])
self.assertIn(curve, sources[1])
self.assertNotIn(area_redim, sources[1])
self.assertNotIn(area, sources[1])
def test_dynamic_compute_overlayable_zorders_mixed_dynamic_and_dynamic_ndoverlay_with_streams_cloned(self):
ndoverlay = DynamicMap(lambda x: NdOverlay({i: Area(range(10+i)) for i in range(2)}),
kdims=[], streams=[PointerX()])
curve = DynamicMap(lambda: Curve(range(10)), kdims=[])
curve_redim = curve.redim(x='x2')
combined = ndoverlay*curve_redim
combined[()]
sources = compute_overlayable_zorders(combined.clone())
self.assertIn(ndoverlay, sources[0])
self.assertNotIn(curve_redim, sources[0])
self.assertNotIn(curve, sources[0])
self.assertIn(ndoverlay, sources[1])
self.assertNotIn(curve_redim, sources[1])
self.assertNotIn(curve, sources[1])
self.assertIn(curve_redim, sources[2])
self.assertIn(curve, sources[2])
self.assertNotIn(ndoverlay, sources[2])
def test_area_datetime_nat(self):
values = [(np.datetime64(dt.datetime(2017, 1, i)), i) for i in range(1, 4)]
values.append((np.datetime64('nat'), np.nan))
values += [(np.datetime64(dt.datetime(2017, 1, i)), i) for i in range(4, 6)]
area = Area(values)
plot = bokeh_renderer.get_plot(area)
cds = plot.handles['cds']
xs = np.array([
'2017-01-01T00:00:00.000000000', '2017-01-02T00:00:00.000000000',
'2017-01-03T00:00:00.000000000', '2017-01-03T00:00:00.000000000',
'2017-01-02T00:00:00.000000000', '2017-01-01T00:00:00.000000000',
'NaT', '2017-01-04T00:00:00.000000000',
'2017-01-05T00:00:00.000000000', '2017-01-05T00:00:00.000000000',
'2017-01-04T00:00:00.000000000'
], dtype='datetime64[ns]')
ys = np.array([
0., 0., 0., 3., 2., 1., np.nan, 0., 0., 5., 4.
])
self.assertEqual(cds.data['x'], xs)
self.assertEqual(cds.data['y'], ys)
def test_dynamic_compute_overlayable_zorders_mixed_dynamic_and_non_dynamic_ndoverlays_reverse(self):
ndoverlay = NdOverlay({i: Area(range(10+i)) for i in range(2)})
curve = DynamicMap(lambda: Curve(range(10)), kdims=[])
curve_redim = curve.redim(x='x2')
combined = curve_redim*ndoverlay
combined[()]
sources = compute_overlayable_zorders(combined)
self.assertIn(curve_redim, sources[0])
self.assertIn(curve, sources[0])
self.assertNotIn(ndoverlay, sources[0])
self.assertIn(ndoverlay[0], sources[1])
self.assertIn(ndoverlay, sources[1])
self.assertNotIn(curve_redim, sources[1])
self.assertNotIn(curve, sources[1])
self.assertIn(ndoverlay[1], sources[2])
self.assertIn(ndoverlay, sources[2])
self.assertNotIn(curve_redim, sources[2])
self.assertNotIn(curve, sources[2])
def test_area_stacked(self):
plot = self.df.hvplot.area(stacked=True)
obj = NdOverlay({'x': Area(self.df, 'index', 'x').redim(x='value'),
'y': Area(self.df, 'index', 'y').redim(y='value')}, 'Variable')
self.assertEqual(plot, Area.stack(obj))
def test_area_selection_numeric_inverted(self):
area = Area([3, 2, 1, 3, 4]).opts(invert_axes=True)
expr, bbox, region = area._get_selection_expr_for_stream_value(bounds=(0, 1, 2, 3))
self.assertEqual(bbox, {'x': (1, 3)})
self.assertEqual(expr.apply(area), np.array([False, True, True, True, False]))
self.assertEqual(region, NdOverlay({0: HSpan(1, 3)}))
def test_area_visible(self):
curve = Area([1, 2, 3]).options(visible=False)
state = self._get_plot_state(curve)
self.assertEqual(state['data'][0]['visible'], False)
def test_area_empty(self):
area = Area([])
plot = bokeh_renderer.get_plot(area)
cds = plot.handles['cds']
self.assertEqual(cds.data['x'], [])
self.assertEqual(cds.data['y'], [])
