def test_dataset_reindex_non_constant(self):
ds = Dataset(self.rgb)
reindexed = ds.reindex(['y'], ['R'])
data = Dataset(ds.columns(['y', 'R']),
kdims=['y'],
vdims=[ds.vdims[0]])
self.assertEqual(reindexed, data)
def setUp(self):
self.df = pd.DataFrame({
'a': [1, 1, 3, 3, 2, 2, 0, 0],
'b': [10, 20, 30, 40, 10, 20, 30, 40],
'c': ['A', 'A', 'B', 'B', 'C', 'C', 'D', 'D'],
'd': [-1, -2, -3, -4, -5, -6, -7, -8]
})
self.ds = Dataset(
self.df,
kdims=[
Dimension('a', label="The a Column"),
Dimension('b', label="The b Column"),
Dimension('c', label="The c Column"),
Dimension('d', label="The d Column"),
]
)
self.ds2 = Dataset(
self.df.iloc[2:],
kdims=[
Dimension('a', label="The a Column"),
Dimension('b', label="The b Column"),
Dimension('c', label="The c Column"),
Dimension('d', label="The d Column"),
]
)
def init_data(self):
self.xs = range(11)
self.xs_2 = [el**2 for el in self.xs]
self.y_ints = [i * 2 for i in range(11)]
self.dataset_hm = Dataset((self.xs, self.y_ints),
kdims=['x'],
vdims=['y'])
self.dataset_hm_alias = Dataset((self.xs, self.y_ints),
kdims=[('x', 'X')],
vdims=[('y', 'Y')])
self.grid_xs = [0, 1]
self.grid_ys = [0.1, 0.2, 0.3]
self.grid_zs = [[0, 1], [2, 3], [4, 5]]
self.dataset_grid = Dataset((self.grid_xs, self.grid_ys, self.grid_zs),
kdims=['x', 'y'],
vdims=['z'])
self.dataset_grid_alias = Dataset(
(self.grid_xs, self.grid_ys, self.grid_zs),
kdims=[('x', 'X'), ('y', 'Y')],
vdims=[('z', 'Z')])
self.dataset_grid_inv = Dataset(
(self.grid_xs[::-1], self.grid_ys[::-1], self.grid_zs),
kdims=['x', 'y'],
vdims=['z'])
def test_dataset_redim_with_alias_dframe(self):
test_df = pd.DataFrame({'x': range(10), 'y': range(0,20,2)})
dataset = Dataset(test_df, kdims=[('x', 'X-label')], vdims=['y'])
redim_df = pd.DataFrame({'X': range(10), 'y': range(0,20,2)})
dataset_redim = Dataset(redim_df, kdims=['X'], vdims=['y'])
self.assertEqual(dataset.redim(**{'X-label':'X'}), dataset_redim)
self.assertEqual(dataset.redim(**{'x':'X'}), dataset_redim)
def test_dataset_sort_vdim_hm(self):
xs_2 = np.array(self.xs_2)
dataset = Dataset(np.column_stack([self.xs, -xs_2]),
kdims=['x'], vdims=['y'])
dataset_sorted = Dataset(np.column_stack([self.xs[::-1], -xs_2[::-1]]),
kdims=['x'], vdims=['y'])
self.assertEqual(dataset.sort('y'), dataset_sorted)
def test_dataset_2D_aggregate_partial_hm(self):
array = np.random.rand(11, 11)
dataset = Dataset({'x':self.xs, 'y':self.y_ints, 'z': array},
kdims=['x', 'y'], vdims=['z'])
self.assertEqual(dataset.aggregate(['x'], np.mean),
Dataset({'x':self.xs, 'z': np.mean(array, axis=0)},
kdims=['x'], vdims=['z']))
def test_collapse_nested(self):
inner1 = UniformNdMapping({1: Dataset([(1, 2)], ['x', 'y'])}, 'Y')
inner2 = UniformNdMapping({1: Dataset([(3, 4)], ['x', 'y'])}, 'Y')
outer = UniformNdMapping({1: inner1, 2: inner2}, 'X')
collapsed = outer.collapse()
expected = Dataset([(1, 1, 1, 2), (2, 1, 3, 4)], ['X', 'Y', 'x', 'y'])
self.assertEqual(collapsed, expected)
def test_dataset_reindex_non_constant(self):
with DatatypeContext([self.datatype, 'dictionary' , 'dataframe', 'grid'], self.rgb):
ds = Dataset(self.rgb)
reindexed = ds.reindex(['y'], ['R'])
data = Dataset(ds.columns(['y', 'R']),
kdims=['y'], vdims=[ds.vdims[0]])
self.assertEqual(reindexed, data)
def test_dataset_reindex_constant(self):
with DatatypeContext([self.datatype, 'dictionary', 'dataframe', 'grid'], self.image):
selected = Dataset(self.image.select(x=0))
reindexed = selected.reindex(['y'])
data = Dataset(selected.columns(['y', 'z']),
kdims=['y'], vdims=['z'])
self.assertEqual(reindexed, data)
def test_dataset_2D_aggregate_partial_hm_alias(self):
array = np.random.rand(11, 11)
dataset = Dataset({'x':self.xs, 'y':self.y_ints, 'z': array},
kdims=[('x', 'X'), ('y', 'Y')], vdims=[('z', 'Z')])
self.assertEqual(dataset.aggregate(['X'], np.mean),
Dataset({'x':self.xs, 'z': np.mean(array, axis=0)},
kdims=[('x', 'X')], vdims=[('z', 'Z')]))
def test_dataset_groupby(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'], vdims=self.vdims)),
('F', Dataset(group2, kdims=['Age'], vdims=self.vdims))],
kdims=['Gender'])
self.assertEqual(self.table.groupby(['Gender']), grouped)
def test_dataset_groupby_dynamic_alias(self):
array = np.random.rand(11, 11)
dataset = Dataset({'x':self.xs, 'y':self.y_ints, 'z': array},
kdims=[('x', 'X'), ('y', 'Y')], vdims=[('z', 'Z')])
grouped = dataset.groupby('X', dynamic=True)
first = Dataset({'y': self.y_ints, 'z': array[:, 0]},
kdims=[('y', 'Y')], vdims=[('z', 'Z')])
self.assertEqual(grouped[0], first)
def test_dataset_sort_vdim_hm_alias(self):
xs_2 = np.array(self.xs_2)
dataset = Dataset(np.column_stack([self.xs, -xs_2]),
kdims=[('x', 'X-label')], vdims=[('y', 'Y-label')])
dataset_sorted = Dataset(np.column_stack([self.xs[::-1], -xs_2[::-1]]),
kdims=[('x', 'X-label')], vdims=[('y', 'Y-label')])
self.assertEqual(dataset.sort('y'), dataset_sorted)
self.assertEqual(dataset.sort('Y-label'), dataset_sorted)
def test_dataset_groupby_dynamic(self):
array = np.random.rand(11, 11)
dataset = Dataset({'x':self.xs, 'y':self.y_ints, 'z': array},
kdims=['x', 'y'], vdims=['z'])
grouped = dataset.groupby('x', dynamic=True)
first = Dataset({'y': self.y_ints, 'z': array[:, 0]},
kdims=['y'], vdims=['z'])
self.assertEqual(grouped[0], first)
def test_dataset_groupby_dynamic_alias(self):
array = np.random.rand(11, 11)
dataset = Dataset({'x':self.xs, 'y':self.y_ints, 'z': array},
kdims=[('x', 'X'), ('y', 'Y')], vdims=[('z', 'Z')])
with DatatypeContext([self.datatype, 'dictionary' , 'dataframe'], dataset):
grouped = dataset.groupby('X', dynamic=True)
first = Dataset({'y': self.y_ints, 'z': array[:, 0]},
kdims=[('y', 'Y')], vdims=[('z', 'Z')])
self.assertEqual(grouped[0], first)
def init_data(self):
self.xs = range(11)
self.xs_2 = [el**2 for el in self.xs]
self.y_ints = [i*2 for i in range(11)]
self.dataset_hm = Dataset((self.xs, self.y_ints),
kdims=['x'], vdims=['y'])
self.dataset_hm_alias = Dataset((self.xs, self.y_ints),
kdims=[('x', 'X')], vdims=[('y', 'Y')])
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'), grouped)
def init_column_data(self):
import dask.array
self.xs = range(11)
self.xs_2 = [el**2 for el in self.xs]
self.y_ints = [i*2 for i in range(11)]
dask_y = dask.array.from_array(np.array(self.y_ints), 2)
self.dataset_hm = Dataset((self.xs, dask_y),
kdims=['x'], vdims=['y'])
self.dataset_hm_alias = Dataset((self.xs, dask_y),
kdims=[('x', 'X')], vdims=[('y', 'Y')])
def setUp(self):
super(NdlocTestCase, self).setUp()
self.ds_grid = Dataset(
(np.arange(4), np.arange(3),
np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])),
kdims=['x', 'y'],
vdims='z')
self.ds2_grid = Dataset(
(np.arange(3), np.arange(3),
np.array([[1, 2, 4], [5, 6, 8], [9, 10, 12]])),
kdims=['x', 'y'],
vdims='z')
def test_dataset_sort_vdim_ht(self):
dataset = Dataset({
'x': self.xs,
'y': -self.ys
},
kdims=['x'],
vdims=['y'])
dataset_sorted = Dataset({
'x': self.xs[::-1],
'y': -self.ys[::-1]
},
kdims=['x'],
vdims=['y'])
self.assertEqual(dataset.sort('y'), dataset_sorted)
def test_dataset_2D_aggregate_partial_ht(self):
dataset = Dataset({
'x': self.xs,
'y': self.ys,
'z': self.zs
},
kdims=['x', 'y'],
vdims=['z'])
reduced = Dataset({
'x': self.xs,
'z': self.zs
},
kdims=['x'],
vdims=['z'])
self.assertEqual(dataset.aggregate(['x'], np.mean), reduced)
def test_dataset_2D_aggregate_partial_hm(self):
z_ints = [el**2 for el in self.y_ints]
dataset = Dataset({
'x': self.xs,
'y': self.y_ints,
'z': z_ints
},
kdims=['x', 'y'],
vdims=['z'])
self.assertEqual(
dataset.aggregate(['x'], np.mean),
Dataset({
'x': self.xs,
'z': z_ints
}, kdims=['x'], vdims=['z']))
def test_dataset_array_init_hm(self):
"Tests support for arrays (homogeneous)"
exception = "None of the available storage backends "\
"were able to support the supplied data format."
with self.assertRaisesRegexp(Exception, exception):
Dataset(np.column_stack([self.xs, self.xs_2]),
kdims=['x'], vdims=['x2'])
def test_holomap_hist_two_dims(self):
hmap = HoloMap({i: Dataset({'x':self.xs, 'y': self.ys * i},
kdims=['x'], vdims=['y'])
for i in range(10)}, kdims=['z'])
hists = hmap.hist(dimension=['x', 'y'])
self.assertEqual(hists['right'].last.kdims, ['y'])
self.assertEqual(hists['top'].last.kdims, ['x'])
def test_heatmap_construct_and_sort(self):
data = [(chr(65+i),chr(97+j), i*j) for i in range(3) for j in [2, 0, 1] if i!=j]
hmap = HeatMap(data).sort()
dataset = Dataset({'x': ['A', 'B', 'C'], 'y': ['a', 'b', 'c'],
'z': [[np.NaN, 0, 0], [0, np.NaN, 2], [0, 2, np.NaN]]},
kdims=['x', 'y'], vdims=['z'])
self.assertEqual(hmap.gridded, dataset)
def test_holomap_redim_nested(self):
hmap = HoloMap({i: Dataset({'x':self.xs, 'y': self.ys * i},
kdims=['x'], vdims=['y'])
for i in range(10)}, kdims=['z'])
redimmed = hmap.redim(x='Time', z='Magnitude')
self.assertEqual(redimmed.dimensions('all', True),
['Magnitude', 'Time', 'y'])
def setUp(self):
self.xs = range(11)
self.y_ints = [i * 2 for i in range(11)]
self.ys = np.linspace(0, 1, 11)
self.columns = Dataset(np.column_stack([self.xs, self.y_ints]),
kdims=['x'],
vdims=['y'])
def test_dataset_ndelement_init_hm(self):
"Tests support for homogeneous NdElement (backwards compatibility)"
exception = "None of the available storage backends "\
"were able to support the supplied data format."
with self.assertRaisesRegexp(Exception, exception):
Dataset(NdElement(zip(self.xs, self.xs_2),
kdims=['x'], vdims=['x2']))
def test_dataset_groupby_drop_dims_dynamic(self):
array = np.random.rand(3, 20, 10)
ds = Dataset({'x': range(10), 'y': range(20), 'z': range(3), 'Val': array},
kdims=['x', 'y', 'z'], vdims=['Val'])
with DatatypeContext([self.datatype, 'columns', 'dataframe']):
partial = ds.to(Dataset, kdims=['x'], vdims=['Val'], groupby='y', dynamic=True)
self.assertEqual(partial[19]['Val'], array[:, -1, :].T.flatten())
def test_dataset_dataframe_init_hm_alias(self):
"Tests support for homogeneous DataFrames"
if pd is None:
raise SkipTest("Pandas not available")
dataset = Dataset(pd.DataFrame({'x':self.xs, 'x2':self.xs_2}),
kdims=[('x', 'X-label')], vdims=[('x2', 'X2-label')])
self.assertTrue(isinstance(dataset.data, self.data_instance_type))
