def test_dataarray_dimension_order(self):
x = np.linspace(-3, 7, 53)
y = np.linspace(-5, 8, 89)
z = np.exp(-1 * (x**2 + y[:, np.newaxis]**2))
array = xr.DataArray(z, coords=[y, x], dims=['x', 'y'])
img = Image(array)
self.assertEqual(img.kdims, [Dimension('x'), Dimension('y')])
def test_xarray_override_dims(self):
xs = [0.1, 0.2, 0.3]
ys = [0, 1]
zs = np.array([[0, 1], [2, 3], [4, 5]])
da = xr.DataArray(zs,
coords=[('x_dim', xs), ('y_dim', ys)],
name="data_name",
dims=['y_dim', 'x_dim'])
da.attrs['long_name'] = "data long name"
da.attrs['units'] = "array_unit"
da.x_dim.attrs['units'] = "x_unit"
da.y_dim.attrs['long_name'] = "y axis long name"
ds = Dataset(da, kdims=["x_dim", "y_dim"], vdims=["z_dim"])
x_dim = Dimension("x_dim")
y_dim = Dimension("y_dim")
z_dim = Dimension("z_dim")
self.assertEqual(ds.kdims[0], x_dim)
self.assertEqual(ds.kdims[1], y_dim)
self.assertEqual(ds.vdims[0], z_dim)
ds_from_ds = Dataset(da.to_dataset(),
kdims=["x_dim", "y_dim"],
vdims=["data_name"])
self.assertEqual(ds_from_ds.kdims[0], x_dim)
self.assertEqual(ds_from_ds.kdims[1], y_dim)
data_dim = Dimension("data_name")
self.assertEqual(ds_from_ds.vdims[0], data_dim)
def test_bivariate_dframe_constructor(self):
dist = Bivariate(
pd.DataFrame({
'x': [0, 1, 2],
'y': [0, 1, 2]
}, columns=['x', 'y']))
self.assertEqual(dist.kdims, [Dimension('x'), Dimension('y')])
self.assertEqual(dist.vdims, [Dimension('Density')])
def test_irregular_and_regular_coordinate_inference_inverted(self):
data = self.get_irregular_dataarray(False)
ds = Dataset(data, vdims='Value')
self.assertEqual(
ds.kdims,
[Dimension('band'),
Dimension('x'), Dimension('y')])
self.assertEqual(ds.dimension_values(3, flat=False),
data.values.transpose([1, 2, 0]))
def test_dataset_extract_vdims(self):
df = pd.DataFrame({
'x': [1, 2, 3],
'y': [1, 2, 3],
'z': [1, 2, 3]
},
columns=['x', 'y', 'z'])
ds = Dataset(df, kdims=['x'])
self.assertEqual(ds.vdims, [Dimension('y'), Dimension('z')])
def test_dataset_element_allowing_two_kdims_with_one_default_kdim(self):
df = pd.DataFrame({
'x': [1, 2, 3],
'y': [1, 2, 3],
'z': [1, 2, 3]
},
columns=['x', 'y', 'z'])
ds = Scatter(df)
self.assertEqual(ds.kdims, [Dimension('x')])
self.assertEqual(ds.vdims, [Dimension('y'), Dimension('z')])
def test_bivariate_dframe_constructor(self):
if pd is None:
raise SkipTest("Test requires pandas, skipping.")
dist = Bivariate(
pd.DataFrame({
'x': [0, 1, 2],
'y': [0, 1, 2]
}, columns=['x', 'y']))
self.assertEqual(dist.kdims, [Dimension('x'), Dimension('y')])
self.assertEqual(dist.vdims, [Dimension('Density')])
def test_dataset_extract_vdims_with_kdims_defined(self):
df = pd.DataFrame({
'x': [1, 2, 3],
'y': [1, 2, 3],
'z': [1, 2, 3]
},
columns=['x', 'y', 'z'])
ds = Points(df, kdims=['x', 'z'])
self.assertEqual(ds.kdims, [Dimension('x'), Dimension('z')])
self.assertEqual(ds.vdims, [Dimension('y')])
def test_dataset_process_index(self):
df = pd.DataFrame({
'x': [1, 2, 3],
'y': [1, 2, 3],
'z': [1, 2, 3]
},
columns=['x', 'y', 'z'])
ds = Dataset(df, 'index')
self.assertEqual(ds.kdims, [Dimension('index')])
self.assertEqual(
ds.vdims,
[Dimension('x'), Dimension('y'),
Dimension('z')])
def init(cls, eltype, data, kdims, vdims):
if kdims:
kdim_names = [
kd.name if isinstance(kd, Dimension) else kd for kd in kdims
]
else:
kdim_names = [kd.name for kd in eltype.kdims]
if not isinstance(data, iris.cube.Cube):
ndims = len(kdim_names)
kdims = [
kd if isinstance(kd, Dimension) else Dimension(kd)
for kd in kdims
]
vdim = vdims[0].name if isinstance(vdims[0],
Dimension) else vdims[0]
if isinstance(data, tuple):
value_array = data[-1]
data = {d: vals for d, vals in zip(kdim_names + [vdim], data)}
elif isinstance(data, dict):
value_array = data[vdim]
coords = [(iris.coords.DimCoord(data[kd.name],
long_name=kd.name,
units=kd.unit), ndims - n - 1)
for n, kd in enumerate(kdims)]
try:
data = iris.cube.Cube(value_array,
long_name=vdim,
dim_coords_and_dims=coords)
except:
pass
if not isinstance(data, iris.cube.Cube):
raise TypeError('Data must be be an iris dataset type.')
if kdims:
coords = []
for kd in kdims:
coord = data.coords(
kd.name if isinstance(kd, Dimension) else kd)
if len(coord) == 0:
raise ValueError('Key dimension %s not found in '
'Iris cube.' % kd)
coords.append(coord[0])
else:
coords = data.dim_coords
coords = sorted(coords, key=sort_coords)
kdims = [coord_to_dimension(crd) for crd in coords]
if vdims is None:
vdims = [Dimension(data.name(), unit=str(data.units))]
return data, {'kdims': kdims, 'vdims': vdims}, {'group': data.name()}
def test_xarray_dataset_names_and_units(self):
xs = [0.1, 0.2, 0.3]
ys = [0, 1]
zs = np.array([[0, 1], [2, 3], [4, 5]])
da = xr.DataArray(zs, coords=[('x_dim', xs), ('y_dim', ys)], name="data_name", dims=['y_dim', 'x_dim'])
da.attrs['long_name'] = "data long name"
da.attrs['units'] = "array_unit"
da.x_dim.attrs['units'] = "x_unit"
da.y_dim.attrs['long_name'] = "y axis long name"
dataset = Dataset(da)
self.assertEqual(dataset.get_dimension("x_dim"), Dimension("x_dim", unit="x_unit"))
self.assertEqual(dataset.get_dimension("y_dim"), Dimension("y_dim", label="y axis long name"))
self.assertEqual(dataset.get_dimension("data_name"),
Dimension("data_name", label="data long name", unit="array_unit"))
def test_distribution_composite_not_filled(self):
dist = Distribution(np.array([0, 1,
2]), ).opts(plot=dict(filled=False))
curve = Compositor.collapse_element(dist, backend='matplotlib')
self.assertIsInstance(curve, Curve)
self.assertEqual(curve.vdims,
[Dimension(('Value_density', 'Value Density'))])
def test_construct_from_xarray(self):
try:
import xarray as xr
except:
raise SkipTest("Test requires xarray")
coords = OrderedDict([('lat', (('y', 'x'), self.ys)),
('lon', (('y', 'x'), self.xs))])
da = xr.DataArray(self.zs, dims=['y', 'x'], coords=coords, name='z')
dataset = Dataset(da)
# Ensure that dimensions are inferred correctly
self.assertEqual(dataset.kdims, [Dimension('lat'), Dimension('lon')])
self.assertEqual(dataset.vdims, [Dimension('z')])
# Ensure that canonicalization works on multi-dimensional coordinates
self.assertEqual(dataset.dimension_values('lon', flat=False), self.xs)
self.assertEqual(dataset.dimension_values('lat', flat=False), self.ys)
self.assertEqual(dataset.dimension_values('z'), self.zs.T.flatten())
def test_dataset_extract_kdims(self):
df = pd.DataFrame({
'x': [1, 2, 3],
'y': [1, 2, 3],
'z': [1, 2, 3]
},
columns=['x', 'y', 'z'])
ds = Distribution(df)
self.assertEqual(ds.kdims, [Dimension('x')])
def coord_to_dimension(coord):
"""
Converts an iris coordinate to a HoloViews dimension.
"""
kwargs = {}
if coord.units.is_time_reference():
kwargs['value_format'] = get_date_format(coord)
else:
kwargs['unit'] = str(coord.units)
return Dimension(coord.name(), **kwargs)
def test_labels_formatter(self):
vdim = Dimension('text', value_format=lambda x: '%.1f' % x)
labels = Labels([(0, 1, 0.33333), (1, 0, 0.66666)], vdims=vdim)
plot = mpl_renderer.get_plot(labels)
artist = plot.handles['artist']
expected = {'x': np.array([0, 1]), 'y': np.array([1, 0]),
'text': ['0.3', '0.7']}
for i, text in enumerate(artist):
self.assertEqual(text._x, expected['x'][i])
self.assertEqual(text._y, expected['y'][i])
self.assertEqual(text.get_text(), expected['text'][i])
def test_labels_formatter(self):
vdim = Dimension('text', value_format=lambda x: '%.1f' % x)
labels = Labels([(0, 1, 0.33333), (1, 0, 0.66666)], vdims=vdim)
plot = bokeh_renderer.get_plot(labels)
source = plot.handles['source']
glyph = plot.handles['glyph']
expected = {'x': np.array([0, 1]), 'y': np.array([1, 0]),
'text': ['0.3', '0.7']}
for k, vals in expected.items():
self.assertEqual(source.data[k], vals)
self.assertEqual(glyph.x, 'x')
self.assertEqual(glyph.y, 'y')
self.assertEqual(glyph.text, 'text')
def init(cls, eltype, data, kdims, vdims):
if kdims:
kdim_names = [
kd.name if isinstance(kd, Dimension) else kd for kd in kdims
]
else:
kdim_names = [kd.name for kd in eltype.kdims]
if not isinstance(data, iris.cube.Cube):
if isinstance(data, tuple):
coords = [
iris.coords.DimCoord(vals, long_name=kd)
for kd, vals in zip(kdim_names, data)
]
value_array = data[-1]
vdim = vdims[0].name if isinstance(vdims[0],
Dimension) else vdims[0]
elif isinstance(data, dict):
vdim = vdims[0].name if isinstance(vdims[0],
Dimension) else vdims[0]
coords = [
iris.coords.DimCoord(vals, long_name=kd)
for kd, vals in data.items() if kd in kdims
]
value_array = data[vdim]
try:
data = iris.cube.Cube(value_array,
long_name=vdim,
dim_coords_and_dims=coords)
except:
pass
if not isinstance(data, iris.cube.Cube):
raise TypeError('Data must be be an iris dataset type.')
if kdims:
coords = []
for kd in kdims:
coord = data.coords(
kd.name if isinstance(kd, Dimension) else kd)
if len(coord) == 0:
raise ValueError('Key dimension %s not found in '
'Iris cube.' % kd)
coords.append(coord[0])
else:
coords = data.dim_coords
coords = sorted(coords, key=sort_coords)
kdims = [coord_to_dimension(crd) for crd in coords]
if vdims is None:
vdims = [Dimension(data.name(), unit=str(data.units))]
return data, kdims, vdims
def init(cls, eltype, data, kdims, vdims):
if not isinstance(data, iris.cube.Cube):
raise TypeError('HoloCube data must be be an iris HoloCube type.')
if kdims:
if len(kdims) != len(data.dim_coords):
raise ValueError('Supplied key dimensions must match '
'HoloCube dim_coords.')
coords = []
for kd in kdims:
coord = data.coords(kd.name if isinstance(kd, Dimension) else kd)
if len(coord) == 0:
raise ValueError('Key dimension %s not found in '
'Iris cube.' % kd)
coords.append(coord[0])
else:
coords = data.dim_coords
coords = sorted(coords, key=util.sort_coords)
kdims = [util.coord_to_dimension(crd) for crd in coords]
if vdims is None:
vdims = [Dimension(data.name(), unit=str(data.units))]
return data, kdims, vdims
def test_bivariate_composite_custom_vdim(self):
dist = Bivariate(np.random.rand(10, 2), vdims=['Test'])
contours = Compositor.collapse_element(dist)
self.assertIsInstance(contours, Contours)
self.assertEqual(contours.vdims, [Dimension('Test')])
def test_distribution_array_constructor(self):
dist = Distribution(np.array([0, 1, 2]))
self.assertEqual(dist.kdims, [Dimension('Value')])
self.assertEqual(dist.vdims, [Dimension('Density')])
def test_bivariate_dict_constructor(self):
dist = Bivariate({'x': [0, 1, 2], 'y': [0, 1, 2]}, ['x', 'y'])
self.assertEqual(dist.kdims, [Dimension('x'), Dimension('y')])
self.assertEqual(dist.vdims, [Dimension('Density')])
def test_bivariate_array_constructor_custom_vdim(self):
dist = Bivariate(np.array([[0, 1, 2], [0, 1, 2]]), vdims=['Test'])
self.assertEqual(dist.kdims, [Dimension('x'), Dimension('y')])
self.assertEqual(dist.vdims, [Dimension('Test')])
def test_distribution_array_constructor_custom_vdim(self):
dist = Distribution(np.array([0, 1, 2]), vdims=['Test'])
self.assertEqual(dist.kdims, [Dimension('Value')])
self.assertEqual(dist.vdims, [Dimension('Test')])
def test_bivariate_array_constructor(self):
dist = Bivariate(np.array([[0, 1, 2], [0, 1, 2]]))
self.assertEqual(dist.kdims, [Dimension('x'), Dimension('y')])
self.assertEqual(dist.vdims, [Dimension('Density')])
def test_distribution_dict_constructor(self):
dist = Distribution({'Value': [0, 1, 2]})
self.assertEqual(dist.kdims, [Dimension('Value')])
self.assertEqual(dist.vdims, [Dimension('Density')])
def test_distribution_series_constructor(self):
if pd is None:
raise SkipTest("Test requires pandas")
dist = Distribution(pd.Series([0, 1, 2], name='Value'))
self.assertEqual(dist.kdims, [Dimension('Value')])
self.assertEqual(dist.vdims, [Dimension('Density')])
def test_bivariate_composite_empty_not_filled(self):
dist = Bivariate([]).opts(plot=dict(filled=True))
contours = Compositor.collapse_element(dist)
self.assertIsInstance(contours, Contours)
self.assertEqual(contours.vdims, [Dimension('Density')])
self.assertEqual(len(contours), 0)
def test_distribution_dframe_constructor(self):
if pd is None:
raise SkipTest("Test requires pandas, skipping.")
dist = Distribution(pd.DataFrame({'Value': [0, 1, 2]}))
self.assertEqual(dist.kdims, [Dimension('Value')])
self.assertEqual(dist.vdims, [Dimension('Density')])
def test_bivariate_composite_filled(self):
dist = Bivariate(np.random.rand(10, 2)).opts(plot=dict(filled=True))
contours = Compositor.collapse_element(dist)
self.assertIsInstance(contours, Polygons)
self.assertEqual(contours.vdims, [Dimension('Density')])
