Python data.Dataset类代码示例

 def test_dimension_values_vdim(self):
     cube = Dataset(self.cube, kdims=['longitude', 'latitude'])
     self.assertEqual(cube.dimension_values('unknown', flat=False),
                      np.flipud(np.array([[ 0,  4,  8],
                                          [ 1,  5,  9],
                                          [ 2,  6, 10],
                                          [ 3,  7, 11]], dtype=np.int32).T))

 def test_dataset_groupby_drop_dims_dynamic_with_vdim(self):
     array = da.from_array(np.random.rand(3, 20, 10), 3)
     ds = Dataset({'x': range(10), 'y': range(20), 'z': range(3), 'Val': array, 'Val2': array*2},
                  kdims=['x', 'y', 'z'], vdims=['Val', 'Val2'])
     with DatatypeContext([self.datatype, 'dictionary' , 'dataframe'], (ds, Dataset)):
         partial = ds.to(Dataset, kdims=['Val'], vdims=['Val2'], groupby='y', dynamic=True)
         self.assertEqual(partial[19]['Val'], array[:, -1, :].T.flatten().compute())

 def test_dataset_2D_aggregate_partial_hm_alias(self):
     array = da.from_array(np.random.rand(11, 11), 3)
     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).compute()},
                              kdims=[('x', 'X')], vdims=[('z', 'Z')]))

 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_dataset_groupby_drop_dims_with_vdim(self):
     array = np.random.rand(3, 20, 10)
     ds = Dataset({'x': range(10), 'y': range(20), 'z': range(3), 'Val': array, 'Val2': array*2},
                  kdims=['x', 'y', 'z'], vdims=['Val', 'Val2'])
     with DatatypeContext([self.datatype, 'dictionary' , 'dataframe'], (ds, Dataset)):
         partial = ds.to(Dataset, kdims=['Val'], vdims=['Val2'], groupby='y')
     self.assertEqual(partial.last['Val'], array[:, -1, :].T.flatten())

 def test_irregular_grid_data_values_inverted_y(self):
     nx, ny = 20, 5
     xs, ys = np.meshgrid(np.arange(nx)+0.5, np.arange(ny)*-1+0.5)
     zs = np.arange(100).reshape(5, 20)
     ds = Dataset((xs, ys, zs), ['x', 'y'], 'z')
     self.assertEqual(ds.dimension_values(2, flat=False), zs)
     self.assertEqual(ds.interface.coords(ds, 'x'), xs)
     self.assertEqual(ds.interface.coords(ds, 'y'), ys)

 def test_dataset_2D_reduce_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(np.array(dataset.reduce(['x', 'y'], np.mean)),
                      np.mean(array))
     self.assertEqual(np.array(dataset.reduce(['X', 'Y'], np.mean)),
                      np.mean(array))

 def test_multi_dimension_groupby(self):
     x, y, z = list('AB'*10), np.arange(20)%3, np.arange(20)
     ds = Dataset((x, y, z), kdims=['x', 'y'], vdims=['z'],  datatype=[self.datatype])
     keys = [('A', 0), ('B', 1), ('A', 2), ('B', 0), ('A', 1), ('B', 2)]
     grouped = ds.groupby(['x', 'y'])
     self.assertEqual(grouped.keys(), keys)
     group = Dataset({'z': [5, 11, 17]}, vdims=['z'])
     self.assertEqual(grouped.last, group)

 def test_select_dropped_dimensions_restoration(self):
     d = np.random.randn(3, 8)
     da = xr.DataArray(d, name='stuff', dims=['chain', 'value'],
         coords=dict(chain=range(d.shape[0]), value=range(d.shape[1])))
     ds = Dataset(da)
     t = ds.select(chain=0)
     self.assertEqual(t.data.dims , dict(chain=1,value=8))
     self.assertEqual(t.data.stuff.shape , (1,8))

 def test_zero_sized_coordinates_range(self):
     da = xr.DataArray(np.empty((2, 0)), dims=('y', 'x'), coords={'x': [], 'y': [0 ,1]}, name='A')
     ds = Dataset(da)
     x0, x1 = ds.range('x')
     self.assertTrue(np.isnan(x0))
     self.assertTrue(np.isnan(x1))
     z0, z1 = ds.range('A')
     self.assertTrue(np.isnan(z0))
     self.assertTrue(np.isnan(z1))

 def test_dataset_groupby_multiple_dims(self):
     dataset = Dataset((range(8), range(8), range(8), range(8),
                        da.from_array(np.random.rand(8, 8, 8, 8), 4)),
                       kdims=['a', 'b', 'c', 'd'], vdims=['Value'])
     grouped = dataset.groupby(['c', 'd'])
     keys = list(product(range(8), range(8)))
     self.assertEqual(list(grouped.keys()), keys)
     for c, d in keys:
         self.assertEqual(grouped[c, d], dataset.select(c=c, d=d).reindex(['a', 'b']))

 def test_dataset_groupby_dynamic_alias(self):
     array = da.from_array(np.random.rand(11, 11), 3)
     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].compute()},
                     kdims=[('y', 'Y')], vdims=[('z', 'Z')])
     self.assertEqual(grouped[0], first)

 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'])
     with DatatypeContext([self.datatype, 'dictionary' , 'dataframe'], dataset):
         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_xarray_dataset_with_scalar_dim_canonicalize(self):
     xs = [0, 1]
     ys = [0.1, 0.2, 0.3]
     zs = np.array([[[0, 1], [2, 3], [4, 5]]])
     xrarr = xr.DataArray(zs, coords={'x': xs, 'y': ys, 't': [1]}, dims=['t', 'y', 'x'])
     xrds = xr.Dataset({'v': xrarr})
     ds = Dataset(xrds, kdims=['x', 'y'], vdims=['v'], datatype=['xarray'])
     canonical = ds.dimension_values(2, flat=False)
     self.assertEqual(canonical.ndim, 2)
     expected = np.array([[0, 1], [2, 3], [4, 5]])
     self.assertEqual(canonical, expected)

 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"))