def test_mpl_bokeh_mpl_via_dict_backend_keyword(self):
curve = Curve([1,2,3])
styled_mpl = curve.opts({'Curve': dict(color='red')}, backend='matplotlib')
styled = styled_mpl.opts({'Curve': dict(color='green')}, backend='bokeh')
mpl_lookup = Store.lookup_options('matplotlib', styled, 'style')
self.assertEqual(mpl_lookup.kwargs['color'], 'red')
bokeh_lookup = Store.lookup_options('bokeh', styled, 'style')
self.assertEqual(bokeh_lookup.kwargs['color'], 'green')
def test_render_to_png(self):
curve = Curve([])
renderer = BokehRenderer.instance(fig='png')
try:
png, info = renderer(curve)
except RuntimeError:
raise SkipTest("Test requires selenium")
self.assertIsInstance(png, bytes)
self.assertEqual(info['file-ext'], 'png')
def test_mpl_bokeh_output_options_group_expandable(self):
original_allowed_kws = Options._output_allowed_kws[:]
Options._output_allowed_kws = ['backend', 'file_format_example']
# Re-register
Store.register({Curve: plotting.mpl.CurvePlot}, 'matplotlib')
Store.register({Curve: plotting.bokeh.CurvePlot}, 'bokeh')
curve_bk = Options('Curve', backend='bokeh', color='blue')
curve_mpl = Options('Curve', backend='matplotlib', color='red',
file_format_example='SVG')
c = Curve([1,2,3])
styled = c.opts(curve_bk, curve_mpl)
self.assertEqual(Store.lookup_options('matplotlib', styled, 'output').kwargs,
{'backend':'matplotlib', 'file_format_example':'SVG'})
self.assertEqual(Store.lookup_options('bokeh', styled, 'output').kwargs,
{})
Options._output_allowed_kws = original_allowed_kws
def test_store_render_combined(self):
curve = Curve([1, 2, 3])
data, metadata = Store.render(curve)
mime_types = {
'text/html', 'application/javascript',
'application/vnd.holoviews_exec.v0+json', 'image/svg+xml',
'image/png'
}
self.assertEqual(set(data), mime_types)
def test_aggregate_with_spreadfn(self):
with DatatypeContext([self.datatype, 'dictionary', 'dataframe'],
self.image):
agg = self.image.aggregate('x', np.mean, np.std)
xs = self.image.dimension_values('x', expanded=False)
mean = self.array.mean(axis=0)
std = self.array.std(axis=0)
self.assertEqual(
agg, Curve((xs, mean, std), kdims=['x'], vdims=['z', 'z_std']))
def test_pre_and_postprocess_hooks(self):
pre_backup = operation._preprocess_hooks
post_backup = operation._postprocess_hooks
operation._preprocess_hooks = [lambda op, x: {'label': str(x.id)}]
operation._postprocess_hooks = [lambda op, x, **kwargs: x.clone(**kwargs)]
curve = Curve([1, 2, 3])
self.assertEqual(operation(curve).label, str(curve.id))
operation._preprocess_hooks = pre_backup
operation._postprocess_hooks = post_backup
def _sample(self, obj, data):
"""
Rasterizes the supplied object in the current region
and samples it with the drawn paths returning an
NdOverlay of Curves.
Note: Because the function returns an NdOverlay containing
a variable number of elements batching must be enabled and
the legend_limit must be set to 0.
"""
if self.path_stream.data is None:
path = self.path
else:
path = self.path_stream.element
if isinstance(obj, TriMesh):
vdim = obj.nodes.vdims[0]
else:
vdim = obj.vdims[0]
if len(path) > 2:
x_range = path.range(0)
y_range = path.range(1)
else:
return NdOverlay({0: Curve([], 'Distance', vdim)})
(x0, x1), (y0, y1) = x_range, y_range
width, height = (max([min([(x1 - x0) / self.resolution, 500]), 10]),
max([min([(y1 - y0) / self.resolution, 500]), 10]))
raster = rasterize(obj,
x_range=x_range,
y_range=y_range,
aggregator=self.aggregator,
width=int(width),
height=int(height),
dynamic=False)
x, y = raster.kdims
sections = []
for g in path.geom():
xs, ys, distance = self._gen_samples(g)
indexes = {x.name: xs, y.name: ys}
points = raster.data.sel_points(method='nearest',
**indexes).to_dataframe()
points['Distance'] = distance
sections.append(Curve(points, 'Distance', vdims=[vdim, x, y]))
return NdOverlay(dict(enumerate(sections)))
def test_aggregate_ndoverlay_count_cat_datetimes_microsecond_timebase(self):
dates = pd.date_range(start="2016-01-01", end="2016-01-03", freq='1D')
xstart = np.datetime64('2015-12-31T23:59:59.723518000', 'us')
xend = np.datetime64('2016-01-03T00:00:00.276482000', 'us')
curve = Curve((dates, [1, 2, 3]))
curve2 = Curve((dates, [3, 2, 1]))
ndoverlay = NdOverlay({0: curve, 1: curve2}, 'Cat')
imgs = aggregate(ndoverlay, aggregator=ds.count_cat('Cat'), width=2, height=2,
x_range=(xstart, xend), dynamic=False)
bounds = (np.datetime64('2015-12-31T23:59:59.723518'), 1.0,
np.datetime64('2016-01-03T00:00:00.276482'), 3.0)
dates = [np.datetime64('2016-01-01T11:59:59.861759000',),
np.datetime64('2016-01-02T12:00:00.138241000')]
expected = Image((dates, [1.5, 2.5], [[1, 0], [0, 2]]),
datatype=['xarray'], bounds=bounds, vdims='Count')
expected2 = Image((dates, [1.5, 2.5], [[0, 1], [1, 1]]),
datatype=['xarray'], bounds=bounds, vdims='Count')
self.assertEqual(imgs[0], expected)
self.assertEqual(imgs[1], expected2)
def plot_function(data):
nonlocal keys
curves = []
keys = data.fields.data_vars if keys == "all" else keys
for var in keys if not isinstance(keys, str) else [keys]:
displayed_field = data.fields[var]
if displayed_field.dims != ('x', ):
continue
curves.append(Curve((displayed_field.squeeze())))
return Layout(curves).cols(1)
def test_rasterize_curve(self):
curve = Curve([(0.2, 0.3), (0.4, 0.7), (0.8, 0.99)])
expected = Image(([0.25, 0.75], [0.25, 0.75], [[1, 0], [1, 1]]),
vdims=['Count'])
img = rasterize(curve,
dynamic=False,
x_range=(0, 1),
y_range=(0, 1),
width=2,
height=2)
self.assertEqual(img, expected)
def test_render_holomap_individual(self):
hmap = HoloMap({i: Curve([1, 2, i]) for i in range(5)})
obj, _ = self.renderer._validate(hmap, None)
self.assertIsInstance(obj, pn.pane.HoloViews)
self.assertEqual(obj.center, True)
self.assertEqual(obj.widget_location, 'right')
self.assertEqual(obj.widget_type, 'individual')
widgets = obj.layout.select(DiscreteSlider)
self.assertEqual(len(widgets), 1)
slider = widgets[0]
self.assertEqual(slider.options, OrderedDict([(str(i), i) for i in range(5)]))
def test_theme_rendering(self):
theme = Theme(
json={'attrs': {
'Figure': {
'outline_line_color': '#444444'
}
}})
self.renderer.theme = theme
plot = self.renderer.get_plot(Curve([]))
self.renderer.components(plot, 'html')
self.assertEqual(plot.state.outline_line_color, '#444444')
def setUp(self):
self.xs = np.linspace(0, 2 * np.pi, 11)
self.hxs = np.arange(len(self.xs))
self.sin = np.sin(self.xs)
self.cos = np.cos(self.xs)
sine_data = np.column_stack((self.xs, self.sin))
cos_data = np.column_stack((self.xs, self.cos))
self.curve = Curve(sine_data)
self.path = Path([sine_data, cos_data])
self.histogram = Histogram((self.hxs, self.sin))
super(ElementConstructorTest, self).setUp()
def test_aggregate_dt_xaxis_constant_yaxis(self):
df = pd.DataFrame({'y': np.ones(100)}, index=pd.date_range('1980-01-01', periods=100, freq='1T'))
img = rasterize(Curve(df), dynamic=False)
xs = np.array(['1980-01-01T00:16:30.000000', '1980-01-01T00:49:30.000000',
'1980-01-01T01:22:30.000000'], dtype='datetime64[us]')
ys = np.array([])
bounds = (np.datetime64('1980-01-01T00:00:00.000000'), 1.0,
np.datetime64('1980-01-01T01:39:00.000000'), 1.0)
expected = Image((xs, ys, np.empty((0, 3))), ['index', 'y'], 'Count',
xdensity=1, ydensity=1, bounds=bounds)
self.assertEqual(img, expected)
def test_aggregate_curve_datetimes(self):
dates = pd.date_range(start="2016-01-01", end="2016-01-03", freq='1D')
curve = Curve((dates, [1, 2, 3]))
img = aggregate(curve, width=2, height=2, dynamic=False)
bounds = (np.datetime64('2016-01-01T00:00:00.000000'), 1.0,
np.datetime64('2016-01-03T00:00:00.000000'), 3.0)
dates = [np.datetime64('2016-01-01T12:00:00.000000000'),
np.datetime64('2016-01-02T12:00:00.000000000')]
expected = Image((dates, [1.5, 2.5], [[1, 0], [0, 2]]),
datatype=['xarray'], bounds=bounds, vdims='Count')
self.assertEqual(img, expected)
def test_theme_rendering(self):
theme = Theme(
json={'attrs': {
'Figure': {
'outline_line_color': '#444444'
}
}})
renderer = BokehRenderer.instance(fig='png')
renderer.theme = theme
plot = renderer.get_plot(Curve([]))
renderer(plot)
self.assertEqual(plot.state.outline_line_color, '#444444')
def test_render_dynamicmap_with_stream(self):
stream = Stream.define(str('Custom'), y=2)()
dmap = DynamicMap(lambda y: Curve([1, 2, y]), kdims=['y'], streams=[stream])
obj, _ = self.renderer._validate(dmap, None)
self.renderer.components(obj)
[(plot, pane)] = obj._plots.values()
y = plot.handles['fig']['data'][0]['y']
self.assertEqual(y[2], 2)
stream.event(y=3)
y = plot.handles['fig']['data'][0]['y']
self.assertEqual(y[2], 3)
def test_render_dynamicmap_with_dims(self):
dmap = DynamicMap(lambda y: Curve([1, 2, y]),
kdims=['y']).redim.range(y=(0.1, 5))
obj, _ = self.renderer._validate(dmap, None)
self.renderer.components(obj)
[(plot, pane)] = obj._plots.values()
cds = plot.handles['cds']
self.assertEqual(cds.data['y'][2], 0.1)
slider = obj.layout.select(FloatSlider)[0]
slider.value = 3.1
self.assertEqual(cds.data['y'][2], 3.1)
def test_render_holomap_scrubber(self):
hmap = HoloMap({i: Curve([1, 2, i]) for i in range(5)})
obj, _ = self.renderer._validate(hmap, 'scrubber')
self.assertIsInstance(obj, pn.pane.HoloViews)
self.assertEqual(obj.center, True)
self.assertEqual(obj.widget_location, 'bottom')
self.assertEqual(obj.widget_type, 'scrubber')
widgets = obj.layout.select(Player)
self.assertEqual(len(widgets), 1)
player = widgets[0]
self.assertEqual(player.start, 0)
self.assertEqual(player.end, 4)
def test_aggregate_curve_datetimes_microsecond_timebase(self):
dates = pd.date_range(start="2016-01-01", end="2016-01-03", freq='1D')
xstart = np.datetime64('2015-12-31T23:59:59.723518000', 'us')
xend = np.datetime64('2016-01-03T00:00:00.276482000', 'us')
curve = Curve((dates, [1, 2, 3]))
img = aggregate(curve, width=2, height=2, x_range=(xstart, xend), dynamic=False)
bounds = (np.datetime64('2015-12-31T23:59:59.723518'), 1.0,
np.datetime64('2016-01-03T00:00:00.276482'), 3.0)
dates = [np.datetime64('2016-01-01T11:59:59.861759000',),
np.datetime64('2016-01-02T12:00:00.138241000')]
expected = Image((dates, [1.5, 2.5], [[1, 0], [0, 2]]),
datatype=['xarray'], bounds=bounds, vdims='Count')
self.assertEqual(img, expected)
def view_scatter(self):
# print('view_scatter')
if self.scatter_toggle and not self.scatter.empty:
return self.scatter_pts.apply.opts(
color_index='z',
cmap=self.cmap_opts.param.colormap,
clim=self.display_range.param.color_range,
colorbar=True,
marker='o',
line_color=None)
else:
return Curve([])
def test_theme_rendering(self):
theme = Theme(
json={
'attrs' : {
'Figure' : {
'outline_line_color': '#444444'}
}
})
self.renderer.theme = theme
plot = self.renderer.get_plot(Curve([]))
diff = self.renderer.diff(plot)
events = [e for e in diff.content['events'] if e.get('attr', None) == 'outline_line_color']
self.assertTrue(bool(events))
self.assertEqual(events[-1]['new']['value'], '#444444')
def test_aggregate_curve_datetimes_dask(self):
df = pd.DataFrame(
data=np.arange(1000), columns=['a'],
index=pd.date_range('2019-01-01', freq='1T', periods=1000),
)
ddf = dd.from_pandas(df, npartitions=4)
curve = Curve(ddf, kdims=['index'], vdims=['a'])
img = aggregate(curve, width=2, height=3, dynamic=False)
bounds = (np.datetime64('2019-01-01T00:00:00.000000'), 0.0,
np.datetime64('2019-01-01T16:39:00.000000'), 999.0)
dates = [np.datetime64('2019-01-01T04:09:45.000000000'),
np.datetime64('2019-01-01T12:29:15.000000000')]
expected = Image((dates, [166.5, 499.5, 832.5], [[332, 0], [167, 166], [0, 334]]),
['index', 'a'], 'Count', datatype=['xarray'], bounds=bounds)
self.assertEqual(img, expected)
def test_overlay_options_partitioned(self):
"""
The new style introduced in #73
"""
data = [zip(range(10),range(10)), zip(range(5),range(5))]
o = Overlay([Curve(c) for c in data])(
dict(plot={'Curve.Curve':{'show_grid':False}},
style={'Curve.Curve':{'color':'k'}}))
self.assertEqual(Store.lookup_options('matplotlib',
o.Curve.I, 'plot').kwargs['show_grid'], False)
self.assertEqual(Store.lookup_options('matplotlib',
o.Curve.II, 'plot').kwargs['show_grid'], False)
self.assertEqual(Store.lookup_options('matplotlib',
o.Curve.I, 'style').kwargs['color'], 'k')
self.assertEqual(Store.lookup_options('matplotlib',
o.Curve.II, 'style').kwargs['color'], 'k')
def test_overlay_options_complete(self):
"""
Complete specification style.
"""
data = [zip(range(10),range(10)), zip(range(5),range(5))]
o = Overlay([Curve(c) for c in data])(
{'Curve.Curve':{'plot':{'show_grid':True},
'style':{'color':'b'}}})
self.assertEqual(Store.lookup_options('matplotlib',
o.Curve.I, 'plot').kwargs['show_grid'], True)
self.assertEqual(Store.lookup_options('matplotlib',
o.Curve.II, 'plot').kwargs['show_grid'], True)
self.assertEqual(Store.lookup_options('matplotlib',
o.Curve.I, 'style').kwargs['color'], 'b')
self.assertEqual(Store.lookup_options('matplotlib',
o.Curve.II, 'style').kwargs['color'], 'b')
def test_render_dynamicmap_with_stream_dims(self):
stream = Stream.define(str('Custom'), y=2)()
dmap = DynamicMap(lambda x, y: Curve([x, 1, y]),
kdims=['x', 'y'],
streams=[stream]).redim.values(x=[1, 2, 3])
obj, _ = self.renderer._validate(dmap, None)
self.renderer.components(obj)
[(plot, pane)] = obj._plots.values()
cds = plot.handles['cds']
self.assertEqual(cds.data['y'][2], 2)
stream.event(y=3)
self.assertEqual(cds.data['y'][2], 3)
self.assertEqual(cds.data['y'][0], 1)
slider = obj.layout.select(DiscreteSlider)[0]
slider.value = 3
self.assertEqual(cds.data['y'][0], 3)
def view_map(self):
# print('view_map method')
if self.adh_mod.mesh.elevation_toggle:
elevation = rasterize(self.adh_mod.mesh.tri_mesh,
aggregator=ds.mean('z'),
precompute=True).apply.opts(
opts.Image(
cmap=self.cmap_opts.colormap,
clim=self.display_range.color_range,
height=self.map_height,
width=self.map_width))
else:
elevation = Curve([]).opts(height=self.map_height,
width=self.map_width)
# return self.adh_mod.mesh.view_bathy() * self.adh_mod.mesh.view_elements(line_color='yellow') * base_map * self.view_scatter()
return elevation * self.adh_mod.mesh.view_elements(
line_color='yellow') * hv.DynamicMap(
self.adh_mod.wmts.view) * self.view_scatter()
def test_render_to_png(self):
curve = Curve([])
renderer = BokehRenderer.instance(fig='png')
png, info = renderer(curve)
self.assertIsInstance(png, bytes)
self.assertEqual(info['file-ext'], 'png')
def test_render_holomap_not_embedded(self):
hmap = HoloMap({i: Curve([1, 2, i]) for i in range(5)})
data, _ = self.renderer.instance(widget_mode='live').components(hmap)
self.assertNotIn('State', data['text/html'])
def test_render_holomap_embedded(self):
hmap = HoloMap({i: Curve([1, 2, i]) for i in range(5)})
data, _ = self.renderer.components(hmap)
self.assertIn('State', data['text/html'])
def test_render_static(self):
curve = Curve([])
obj, _ = self.renderer._validate(curve, None)
self.assertIsInstance(obj, CurvePlot)
def test_hist_curve_int_edges_construct(self):
hist = Histogram(Curve(range(3)))
values = hist.dimension_values(1)
edges = hist.edges
self.assertEqual(values, np.arange(3))
self.assertEqual(edges, np.array([-.5, .5, 1.5, 2.5]))
