def setUp(self):

self.attrs = {'attr1': 'value1', 'attr2': 2929}

self.x = np.random.random((10, 20))

self.v = Variable(['x', 'y'], self.x)

self.va = Variable(['x', 'y'], self.x, self.attrs)

self.ds = Dataset({'foo': self.v})

self.dv = self.ds['foo']

self.mindex = pd.MultiIndex.from_product([['a', 'b'], [1, 2]],

names=('level_1', 'level_2'))

self.mda = DataArray([0, 1, 2, 3], coords={'x': self.mindex}, dims='x')

def test_repr(self):

v = Variable(['time', 'x'], [[1, 2, 3], [4, 5, 6]], {'foo': 'bar'})

coords = OrderedDict([('x', np.arange(3, dtype=np.int64)),

('other', np.int64(0))])

data_array = DataArray(v, coords, name='my_variable')

expected = dedent("""\

foo: bar""")

self.assertEqual(expected, repr(data_array))

def test_repr_multiindex(self):

expected = dedent("""\

- level_2 (x) int64 1 2 1 2""")

self.assertEqual(expected, repr(self.mda))

def test_properties(self):

self.assertVariableEqual(self.dv.variable, self.v)

self.assertArrayEqual(self.dv.values, self.v.values)

for attr in ['dims', 'dtype', 'shape', 'size', 'nbytes',

'ndim', 'attrs']:

self.assertEqual(getattr(self.dv, attr), getattr(self.v, attr))

self.assertEqual(len(self.dv), len(self.v))

self.assertVariableEqual(self.dv.variable, self.v)

self.assertItemsEqual(list(self.dv.coords), list(self.ds.coords))

for k, v in iteritems(self.dv.coords):

self.assertArrayEqual(v, self.ds.coords[k])

with pytest.raises(AttributeError):

self.dv.dataset

self.assertIsInstance(self.ds['x'].to_index(), pd.Index)

with raises_regex(ValueError, 'must be 1-dimensional'):

self.ds['foo'].to_index()

with pytest.raises(AttributeError):

self.dv.variable = self.v

def test_data_property(self):

array = DataArray(np.zeros((3, 4)))

actual = array.copy()

actual.values = np.ones((3, 4))

self.assertArrayEqual(np.ones((3, 4)), actual.values)

actual.data = 2 * np.ones((3, 4))

self.assertArrayEqual(2 * np.ones((3, 4)), actual.data)

self.assertArrayEqual(actual.data, actual.values)

def test_indexes(self):

array = DataArray(np.zeros((2, 3)),

[('x', [0, 1]), ('y', ['a', 'b', 'c'])])

expected = OrderedDict([('x', pd.Index([0, 1])),

('y', pd.Index(['a', 'b', 'c']))])

assert array.indexes.keys() == expected.keys()

for k in expected:

assert array.indexes[k].equals(expected[k])

def test_get_index(self):

array = DataArray(np.zeros((2, 3)), coords={'x': ['a', 'b']},

dims=['x', 'y'])

assert array.get_index('x').equals(pd.Index(['a', 'b']))

assert array.get_index('y').equals(pd.Index([0, 1, 2]))

with pytest.raises(KeyError):

array.get_index('z')

def test_get_index_size_zero(self):

array = DataArray(np.zeros((0,)), dims=['x'])

actual = array.get_index('x')

expected = pd.Index([], dtype=np.int64)

assert actual.equals(expected)

assert actual.dtype == expected.dtype

def test_struct_array_dims(self):

"""

# GH837, GH861

# checking array subraction when dims are the same

p_data = np.array([('John', 180), ('Stacy', 150), ('Dick', 200)],

dtype=[('name', '|S256'), ('height', object)])

p_data_1 = np.array([('John', 180), ('Stacy', 150), ('Dick', 200)],

dtype=[('name', '|S256'), ('height', object)])

p_data_2 = np.array([('John', 180), ('Dick', 200)],

dtype=[('name', '|S256'), ('height', object)])

weights_0 = DataArray([80, 56, 120], dims=['participant'],

coords={'participant': p_data})

weights_1 = DataArray([81, 52, 115], dims=['participant'],

coords={'participant': p_data_1})

actual = weights_1 - weights_0

expected = DataArray([1, -4, -5], dims=['participant'],

coords={'participant': p_data})

self.assertDataArrayIdentical(actual, expected)

# checking array subraction when dims are not the same

p_data_1 = np.array([('John', 180), ('Stacy', 151), ('Dick', 200)],

dtype=[('name', '|S256'), ('height', object)])

weights_1 = DataArray([81, 52, 115], dims=['participant'],

coords={'participant': p_data_1})

actual = weights_1 - weights_0

expected = DataArray([1, -5], dims=['participant'],

coords={'participant': p_data_2})

self.assertDataArrayIdentical(actual, expected)

# checking array subraction when dims are not the same and one

# is np.nan

p_data_1 = np.array([('John', 180), ('Stacy', np.nan), ('Dick', 200)],

dtype=[('name', '|S256'), ('height', object)])

weights_1 = DataArray([81, 52, 115], dims=['participant'],

coords={'participant': p_data_1})

actual = weights_1 - weights_0

expected = DataArray([1, -5], dims=['participant'],

coords={'participant': p_data_2})

self.assertDataArrayIdentical(actual, expected)

def test_name(self):

arr = self.dv

self.assertEqual(arr.name, 'foo')

copied = arr.copy()

arr.name = 'bar'

self.assertEqual(arr.name, 'bar')

self.assertDataArrayEqual(copied, arr)

actual = DataArray(IndexVariable('x', [3]))

actual.name = 'y'

expected = DataArray([3], [('x', [3])], name='y')

self.assertDataArrayIdentical(actual, expected)

def test_dims(self):

arr = self.dv

self.assertEqual(arr.dims, ('x', 'y'))

with raises_regex(AttributeError, 'you cannot assign'):

arr.dims = ('w', 'z')

def test_sizes(self):

array = DataArray(np.zeros((3, 4)), dims=['x', 'y'])

self.assertEqual(array.sizes, {'x': 3, 'y': 4})

self.assertEqual(tuple(array.sizes), array.dims)

with pytest.raises(TypeError):

array.sizes['foo'] = 5

def test_encoding(self):

expected = {'foo': 'bar'}

self.dv.encoding['foo'] = 'bar'

assert expected == self.dv.encoding

expected = {'baz': 0}

self.dv.encoding = expected

assert expected == self.dv.encoding

self.assertIsNot(expected, self.dv.encoding)

def test_constructor(self):

data = np.random.random((2, 3))

actual = DataArray(data)

expected = Dataset({None: (['dim_0', 'dim_1'], data)})[None]

self.assertDataArrayIdentical(expected, actual)

actual = DataArray(data, [['a', 'b'], [-1, -2, -3]])

expected = Dataset({None: (['dim_0', 'dim_1'], data),

'dim_0': ('dim_0', ['a', 'b']),

'dim_1': ('dim_1', [-1, -2, -3])})[None]

self.assertDataArrayIdentical(expected, actual)

actual = DataArray(data, [pd.Index(['a', 'b'], name='x'),

pd.Index([-1, -2, -3], name='y')])

expected = Dataset({None: (['x', 'y'], data),

'x': ('x', ['a', 'b']),

'y': ('y', [-1, -2, -3])})[None]

self.assertDataArrayIdentical(expected, actual)

coords = [['a', 'b'], [-1, -2, -3]]

actual = DataArray(data, coords, ['x', 'y'])

self.assertDataArrayIdentical(expected, actual)

coords = [pd.Index(['a', 'b'], name='A'),

pd.Index([-1, -2, -3], name='B')]

actual = DataArray(data, coords, ['x', 'y'])

self.assertDataArrayIdentical(expected, actual)

coords = {'x': ['a', 'b'], 'y': [-1, -2, -3]}

actual = DataArray(data, coords, ['x', 'y'])

self.assertDataArrayIdentical(expected, actual)

coords = [('x', ['a', 'b']), ('y', [-1, -2, -3])]

actual = DataArray(data, coords)

self.assertDataArrayIdentical(expected, actual)

expected = Dataset({None: (['x', 'y'], data),

'x': ('x', ['a', 'b'])})[None]

actual = DataArray(data, {'x': ['a', 'b']}, ['x', 'y'])

self.assertDataArrayIdentical(expected, actual)

actual = DataArray(data, dims=['x', 'y'])

expected = Dataset({None: (['x', 'y'], data)})[None]

self.assertDataArrayIdentical(expected, actual)

actual = DataArray(data, dims=['x', 'y'], name='foo')

expected = Dataset({'foo': (['x', 'y'], data)})['foo']

self.assertDataArrayIdentical(expected, actual)

actual = DataArray(data, name='foo')

expected = Dataset({'foo': (['dim_0', 'dim_1'], data)})['foo']

self.assertDataArrayIdentical(expected, actual)

actual = DataArray(data, dims=['x', 'y'], attrs={'bar': 2})

expected = Dataset({None: (['x', 'y'], data, {'bar': 2})})[None]

self.assertDataArrayIdentical(expected, actual)

actual = DataArray(data, dims=['x', 'y'], encoding={'bar': 2})

expected = Dataset({None: (['x', 'y'], data, {}, {'bar': 2})})[None]

self.assertDataArrayIdentical(expected, actual)

def test_constructor_invalid(self):

data = np.random.randn(3, 2)

with raises_regex(ValueError, 'coords is not dict-like'):

DataArray(data, [[0, 1, 2]], ['x', 'y'])

with raises_regex(ValueError, 'not a subset of the .* dim'):

DataArray(data, {'x': [0, 1, 2]}, ['a', 'b'])

with raises_regex(ValueError, 'not a subset of the .* dim'):

DataArray(data, {'x': [0, 1, 2]})

with raises_regex(TypeError, 'is not a string'):

DataArray(data, dims=['x', None])

with raises_regex(ValueError, 'conflicting sizes for dim'):

DataArray([1, 2, 3], coords=[('x', [0, 1])])

with raises_regex(ValueError, 'conflicting sizes for dim'):

DataArray([1, 2], coords={'x': [0, 1], 'y': ('x', [1])}, dims='x')

with raises_regex(ValueError, 'conflicting MultiIndex'):

DataArray(np.random.rand(4, 4),

[('x', self.mindex), ('y', self.mindex)])

with raises_regex(ValueError, 'conflicting MultiIndex'):

DataArray(np.random.rand(4, 4),

[('x', self.mindex), ('level_1', range(4))])

with raises_regex(ValueError, 'matching the dimension size'):

DataArray(data, coords={'x': 0}, dims=['x', 'y'])

def test_constructor_from_self_described(self):

data = [[-0.1, 21], [0, 2]]

expected = DataArray(data,

coords={'x': ['a', 'b'], 'y': [-1, -2]},

dims=['x', 'y'], name='foobar',

attrs={'bar': 2}, encoding={'foo': 3})

actual = DataArray(expected)

self.assertDataArrayIdentical(expected, actual)

actual = DataArray(expected.values, actual.coords)

self.assertDataArrayEqual(expected, actual)

frame = pd.DataFrame(data, index=pd.Index(['a', 'b'], name='x'),

columns=pd.Index([-1, -2], name='y'))

actual = DataArray(frame)

self.assertDataArrayEqual(expected, actual)

series = pd.Series(data[0], index=pd.Index([-1, -2], name='y'))

actual = DataArray(series)

self.assertDataArrayEqual(expected[0].reset_coords('x', drop=True),

actual)

panel = pd.Panel({0: frame})

actual = DataArray(panel)

expected = DataArray([data], expected.coords, ['dim_0', 'x', 'y'])

expected['dim_0'] = [0]

self.assertDataArrayIdentical(expected, actual)

expected = DataArray(data,

coords={'x': ['a', 'b'], 'y': [-1, -2],

'a': 0, 'z': ('x', [-0.5, 0.5])},

dims=['x', 'y'])

actual = DataArray(expected)

self.assertDataArrayIdentical(expected, actual)

actual = DataArray(expected.values, expected.coords)

self.assertDataArrayIdentical(expected, actual)

expected = Dataset({'foo': ('foo', ['a', 'b'])})['foo']

actual = DataArray(pd.Index(['a', 'b'], name='foo'))

self.assertDataArrayIdentical(expected, actual)

actual = DataArray(IndexVariable('foo', ['a', 'b']))

self.assertDataArrayIdentical(expected, actual)

def test_constructor_from_0d(self):

expected = Dataset({None: ([], 0)})[None]

actual = DataArray(0)

self.assertDataArrayIdentical(expected, actual)

@requires_dask

def test_constructor_dask_coords(self):

# regression test for GH1684

import dask.array as da

coord = da.arange(8, chunks=(4,))

data = da.random.random((8, 8), chunks=(4, 4)) + 1

actual = DataArray(data, coords={'x': coord, 'y': coord},

dims=['x', 'y'])

ecoord = np.arange(8)

expected = DataArray(data, coords={'x': ecoord, 'y': ecoord},

dims=['x', 'y'])

assert_equal(actual, expected)

def test_equals_and_identical(self):

orig = DataArray(np.arange(5.0), {'a': 42}, dims='x')

expected = orig

actual = orig.copy()

self.assertTrue(expected.equals(actual))

self.assertTrue(expected.identical(actual))

actual = expected.rename('baz')

self.assertTrue(expected.equals(actual))

self.assertFalse(expected.identical(actual))

actual = expected.rename({'x': 'xxx'})

self.assertFalse(expected.equals(actual))

self.assertFalse(expected.identical(actual))

actual = expected.copy()

actual.attrs['foo'] = 'bar'

self.assertTrue(expected.equals(actual))

self.assertFalse(expected.identical(actual))

actual = expected.copy()

actual['x'] = ('x', -np.arange(5))

self.assertFalse(expected.equals(actual))

self.assertFalse(expected.identical(actual))

actual = expected.reset_coords(drop=True)

self.assertFalse(expected.equals(actual))

self.assertFalse(expected.identical(actual))

actual = orig.copy()

actual[0] = np.nan

expected = actual.copy()

self.assertTrue(expected.equals(actual))

self.assertTrue(expected.identical(actual))

actual[:] = np.nan

self.assertFalse(expected.equals(actual))

self.assertFalse(expected.identical(actual))

actual = expected.copy()

actual['a'] = 100000

self.assertFalse(expected.equals(actual))

self.assertFalse(expected.identical(actual))

def test_equals_failures(self):

orig = DataArray(np.arange(5.0), {'a': 42}, dims='x')

self.assertFalse(orig.equals(np.arange(5)))

self.assertFalse(orig.identical(123))

self.assertFalse(orig.broadcast_equals({1: 2}))

def test_broadcast_equals(self):

a = DataArray([0, 0], {'y': 0}, dims='x')

b = DataArray([0, 0], {'y': ('x', [0, 0])}, dims='x')

self.assertTrue(a.broadcast_equals(b))

self.assertTrue(b.broadcast_equals(a))

self.assertFalse(a.equals(b))

self.assertFalse(a.identical(b))

c = DataArray([0], coords={'x': 0}, dims='y')

self.assertFalse(a.broadcast_equals(c))

self.assertFalse(c.broadcast_equals(a))

def test_getitem(self):

# strings pull out dataarrays

self.assertDataArrayIdentical(self.dv, self.ds['foo'])

x = self.dv['x']

y = self.dv['y']

self.assertDataArrayIdentical(self.ds['x'], x)

self.assertDataArrayIdentical(self.ds['y'], y)

I = ReturnItem() # noqa: E741 # allow ambiguous name

for i in [I[:], I[...], I[x.values], I[x.variable], I[x], I[x, y],

I[x.values > -1], I[x.variable > -1], I[x > -1],

I[x > -1, y > -1]]:

self.assertVariableEqual(self.dv, self.dv[i])

for i in [I[0], I[:, 0], I[:3, :2],

I[x.values[:3]], I[x.variable[:3]],

I[x[:3]], I[x[:3], y[:4]],

I[x.values > 3], I[x.variable > 3],

I[x > 3], I[x > 3, y > 3]]:

assert_array_equal(self.v[i], self.dv[i])

def test_getitem_dict(self):

actual = self.dv[{'x': slice(3), 'y': 0}]

expected = self.dv.isel(x=slice(3), y=0)

self.assertDataArrayIdentical(expected, actual)

def test_getitem_coords(self):

orig = DataArray([[10], [20]],

{'x': [1, 2], 'y': [3], 'z': 4,

'x2': ('x', ['a', 'b']),

'y2': ('y', ['c']),

'xy': (['y', 'x'], [['d', 'e']])},

dims=['x', 'y'])

self.assertDataArrayIdentical(orig, orig[:])

self.assertDataArrayIdentical(orig, orig[:, :])

self.assertDataArrayIdentical(orig, orig[...])

self.assertDataArrayIdentical(orig, orig[:2, :1])

self.assertDataArrayIdentical(orig, orig[[0, 1], [0]])

actual = orig[0, 0]

expected = DataArray(

10, {'x': 1, 'y': 3, 'z': 4, 'x2': 'a', 'y2': 'c', 'xy': 'd'})

self.assertDataArrayIdentical(expected, actual)

actual = orig[0, :]

expected = DataArray(

[10], {'x': 1, 'y': [3], 'z': 4, 'x2': 'a', 'y2': ('y', ['c']),

'xy': ('y', ['d'])},

dims='y')

self.assertDataArrayIdentical(expected, actual)

actual = orig[:, 0]

expected = DataArray(

[10, 20], {'x': [1, 2], 'y': 3, 'z': 4, 'x2': ('x', ['a', 'b']),

'y2': 'c', 'xy': ('x', ['d', 'e'])},

dims='x')

self.assertDataArrayIdentical(expected, actual)

def test_getitem_dataarray(self):

# It should not conflict

da = DataArray(np.arange(12).reshape((3, 4)), dims=['x', 'y'])

ind = DataArray([[0, 1], [0, 1]], dims=['x', 'z'])

actual = da[ind]

self.assertArrayEqual(actual, da.values[[[0, 1], [0, 1]], :])

da = DataArray(np.arange(12).reshape((3, 4)), dims=['x', 'y'],

coords={'x': [0, 1, 2], 'y': ['a', 'b', 'c', 'd']})

ind = xr.DataArray([[0, 1], [0, 1]], dims=['X', 'Y'])

actual = da[ind]

expected = da.values[[[0, 1], [0, 1]], :]

self.assertArrayEqual(actual, expected)

assert actual.dims == ('X', 'Y', 'y')

# boolean indexing

ind = xr.DataArray([True, True, False], dims=['x'])

self.assertDataArrayEqual(da[ind], da[[0, 1], :])

self.assertDataArrayEqual(da[ind], da[[0, 1]])

self.assertDataArrayEqual(da[ind], da[ind.values])

def test_setitem(self):

# basic indexing should work as numpy's indexing

tuples = [(0, 0), (0, slice(None, None)),

(slice(None, None), slice(None, None)),

(slice(None, None), 0),

([1, 0], slice(None, None)),

(slice(None, None), [1, 0])]

for t in tuples:

expected = np.arange(6).reshape(3, 2)

orig = DataArray(np.arange(6).reshape(3, 2),

{'x': [1, 2, 3], 'y': ['a', 'b'], 'z': 4,

'x2': ('x', ['a', 'b', 'c']),

'y2': ('y', ['d', 'e'])},

dims=['x', 'y'])

orig[t] = 1

expected[t] = 1

self.assertArrayEqual(orig.values, expected)

def test_setitem_fancy(self):

# vectorized indexing

da = DataArray(np.ones((3, 2)), dims=['x', 'y'])

ind = Variable(['a'], [0, 1])

da[dict(x=ind, y=ind)] = 0

expected = DataArray([[0, 1], [1, 0], [1, 1]], dims=['x', 'y'])

self.assertDataArrayIdentical(expected, da)

# assign another 0d-variable

da[dict(x=ind, y=ind)] = Variable((), 0)

expected = DataArray([[0, 1], [1, 0], [1, 1]], dims=['x', 'y'])

self.assertDataArrayIdentical(expected, da)

# assign another 1d-variable

da[dict(x=ind, y=ind)] = Variable(['a'], [2, 3])

expected = DataArray([[2, 1], [1, 3], [1, 1]], dims=['x', 'y'])

self.assertVariableIdentical(expected, da)

# 2d-vectorized indexing

da = DataArray(np.ones((3, 2)), dims=['x', 'y'])

ind_x = DataArray([[0, 1]], dims=['a', 'b'])

ind_y = DataArray([[1, 0]], dims=['a', 'b'])

da[dict(x=ind_x, y=ind_y)] = 0

expected = DataArray([[1, 0], [0, 1], [1, 1]], dims=['x', 'y'])

self.assertVariableIdentical(expected, da)

da = DataArray(np.ones((3, 2)), dims=['x', 'y'])

ind = Variable(['a'], [0, 1])

da[ind] = 0

expected = DataArray([[0, 0], [0, 0], [1, 1]], dims=['x', 'y'])

self.assertVariableIdentical(expected, da)

def test_setitem_dataarray(self):

def get_data():

return DataArray(np.ones((4, 3, 2)), dims=['x', 'y', 'z'],

coords={'x': np.arange(4), 'y': ['a', 'b', 'c'],

'non-dim': ('x', [1, 3, 4, 2])})

da = get_data()

# indexer with inconsistent coordinates.

ind = DataArray(np.arange(1, 4), dims=['x'],

coords={'x': np.random.randn(3)})

with raises_regex(IndexError, "dimension coordinate 'x'"):

da[dict(x=ind)] = 0

# indexer with consistent coordinates.

ind = DataArray(np.arange(1, 4), dims=['x'],

coords={'x': np.arange(1, 4)})

da[dict(x=ind)] = 0 # should not raise

assert np.allclose(da[dict(x=ind)].values, 0)

self.assertDataArrayIdentical(da['x'], get_data()['x'])

self.assertDataArrayIdentical(da['non-dim'], get_data()['non-dim'])

da = get_data()

# conflict in the assigning values

value = xr.DataArray(np.zeros((3, 3, 2)), dims=['x', 'y', 'z'],

coords={'x': [0, 1, 2],

'non-dim': ('x', [0, 2, 4])})

with raises_regex(IndexError, "dimension coordinate 'x'"):

da[dict(x=ind)] = value

# consistent coordinate in the assigning values

value = xr.DataArray(np.zeros((3, 3, 2)), dims=['x', 'y', 'z'],

coords={'x': [1, 2, 3],

'non-dim': ('x', [0, 2, 4])})

da[dict(x=ind)] = value

assert np.allclose(da[dict(x=ind)].values, 0)

self.assertDataArrayIdentical(da['x'], get_data()['x'])

self.assertDataArrayIdentical(da['non-dim'], get_data()['non-dim'])

# Conflict in the non-dimension coordinate

value = xr.DataArray(np.zeros((3, 3, 2)), dims=['x', 'y', 'z'],

coords={'x': [1, 2, 3],

'non-dim': ('x', [0, 2, 4])})

da[dict(x=ind)] = value # should not raise

# conflict in the assigning values

value = xr.DataArray(np.zeros((3, 3, 2)), dims=['x', 'y', 'z'],

coords={'x': [0, 1, 2],

'non-dim': ('x', [0, 2, 4])})

with raises_regex(IndexError, "dimension coordinate 'x'"):

da[dict(x=ind)] = value

# consistent coordinate in the assigning values

value = xr.DataArray(np.zeros((3, 3, 2)), dims=['x', 'y', 'z'],

coords={'x': [1, 2, 3],

'non-dim': ('x', [0, 2, 4])})

da[dict(x=ind)] = value # should not raise

def test_contains(self):

data_array = DataArray(1, coords={'x': 2})

with pytest.warns(FutureWarning):

assert 'x' in data_array

def test_attr_sources_multiindex(self):

# make sure attr-style access for multi-index levels

# returns DataArray objects

self.assertIsInstance(self.mda.level_1, DataArray)

def test_pickle(self):

data = DataArray(np.random.random((3, 3)), dims=('id', 'time'))

roundtripped = pickle.loads(pickle.dumps(data))

self.assertDataArrayIdentical(data, roundtripped)

@requires_dask

def test_chunk(self):

unblocked = DataArray(np.ones((3, 4)))

self.assertIsNone(unblocked.chunks)

blocked = unblocked.chunk()

self.assertEqual(blocked.chunks, ((3,), (4,)))

blocked = unblocked.chunk(chunks=((2, 1), (2, 2)))

self.assertEqual(blocked.chunks, ((2, 1), (2, 2)))

blocked = unblocked.chunk(chunks=(3, 3))

self.assertEqual(blocked.chunks, ((3,), (3, 1)))

self.assertIsNone(blocked.load().chunks)

# Check that kwargs are passed

import dask.array as da

blocked = unblocked.chunk(name_prefix='testname_')

self.assertIsInstance(blocked.data, da.Array)

assert 'testname_' in blocked.data.name

def test_isel(self):

self.assertDataArrayIdentical(self.dv[0], self.dv.isel(x=0))

self.assertDataArrayIdentical(self.dv, self.dv.isel(x=slice(None)))

self.assertDataArrayIdentical(self.dv[:3], self.dv.isel(x=slice(3)))

self.assertDataArrayIdentical(self.dv[:3, :5],

self.dv.isel(x=slice(3), y=slice(5)))

def test_isel_types(self):

# regression test for #1405

da = DataArray([1, 2, 3], dims='x')

# uint64

self.assertDataArrayIdentical(da.isel(x=np.array([0], dtype="uint64")),

da.isel(x=np.array([0])))

# uint32

self.assertDataArrayIdentical(da.isel(x=np.array([0], dtype="uint32")),

da.isel(x=np.array([0])))

# int64

self.assertDataArrayIdentical(da.isel(x=np.array([0], dtype="int64")),

da.isel(x=np.array([0])))

def test_isel_fancy(self):

shape = (10, 7, 6)

np_array = np.random.random(shape)

da = DataArray(np_array, dims=['time', 'y', 'x'],

coords={'time': np.arange(0, 100, 10)})

y = [1, 3]

x = [3, 0]

expected = da.values[:, y, x]

actual = da.isel(y=(('test_coord', ), y), x=(('test_coord', ), x))

assert actual.coords['test_coord'].shape == (len(y), )

assert list(actual.coords) == ['time']

assert actual.dims == ('time', 'test_coord')

np.testing.assert_equal(actual, expected)

# a few corner cases

da.isel(time=(('points',), [1, 2]), x=(('points',), [2, 2]),

y=(('points',), [3, 4]))

np.testing.assert_allclose(

da.isel_points(time=[1], x=[2], y=[4]).values.squeeze(),

np_array[1, 4, 2].squeeze())

da.isel(time=(('points', ), [1, 2]))

y = [-1, 0]

x = [-2, 2]

expected = da.values[:, y, x]

actual = da.isel(x=(('points', ), x), y=(('points', ), y)).values

np.testing.assert_equal(actual, expected)

# test that the order of the indexers doesn't matter

self.assertDataArrayIdentical(

da.isel(y=(('points', ), y), x=(('points', ), x)),

da.isel(x=(('points', ), x), y=(('points', ), y)))

# make sure we're raising errors in the right places

with raises_regex(IndexError,

'Dimensions of indexers mismatch'):

da.isel(y=(('points', ), [1, 2]), x=(('points', ), [1, 2, 3]))

# tests using index or DataArray as indexers

stations = Dataset()

stations['station'] = (('station', ), ['A', 'B', 'C'])

stations['dim1s'] = (('station', ), [1, 2, 3])

stations['dim2s'] = (('station', ), [4, 5, 1])

actual = da.isel(x=stations['dim1s'], y=stations['dim2s'])

assert 'station' in actual.coords

assert 'station' in actual.dims

self.assertDataArrayIdentical(actual['station'], stations['station'])

with raises_regex(ValueError, 'conflicting values for '):

da.isel(x=DataArray([0, 1, 2], dims='station',

coords={'station': [0, 1, 2]}),

y=DataArray([0, 1, 2], dims='station',

coords={'station': [0, 1, 3]}))

# multi-dimensional selection

stations = Dataset()

stations['a'] = (('a', ), ['A', 'B', 'C'])

stations['b'] = (('b', ), [0, 1])

stations['dim1s'] = (('a', 'b'), [[1, 2], [2, 3], [3, 4]])

stations['dim2s'] = (('a', ), [4, 5, 1])

actual = da.isel(x=stations['dim1s'], y=stations['dim2s'])

assert 'a' in actual.coords

assert 'a' in actual.dims

assert 'b' in actual.coords

assert 'b' in actual.dims

self.assertDataArrayIdentical(actual['a'], stations['a'])

self.assertDataArrayIdentical(actual['b'], stations['b'])

expected = da.variable[:, stations['dim2s'].variable,

stations['dim1s'].variable]

self.assertArrayEqual(actual, expected)

def test_sel(self):

self.ds['x'] = ('x', np.array(list('abcdefghij')))

da = self.ds['foo']

self.assertDataArrayIdentical(da, da.sel(x=slice(None)))

self.assertDataArrayIdentical(da[1], da.sel(x='b'))

self.assertDataArrayIdentical(da[:3], da.sel(x=slice('c')))

self.assertDataArrayIdentical(da[:3], da.sel(x=['a', 'b', 'c']))

self.assertDataArrayIdentical(da[:, :4], da.sel(y=(self.ds['y'] < 4)))

# verify that indexing with a dataarray works

b = DataArray('b')

self.assertDataArrayIdentical(da[1], da.sel(x=b))

self.assertDataArrayIdentical(da[[1]], da.sel(x=slice(b, b)))

def test_sel_dataarray(self):

# indexing with DataArray

self.ds['x'] = ('x', np.array(list('abcdefghij')))

da = self.ds['foo']

ind = DataArray(['a', 'b', 'c'], dims=['x'])

actual = da.sel(x=ind)

self.assertDataArrayIdentical(actual, da.isel(x=[0, 1, 2]))

# along new dimension

ind = DataArray(['a', 'b', 'c'], dims=['new_dim'])

actual = da.sel(x=ind)

self.assertArrayEqual(actual, da.isel(x=[0, 1, 2]))

assert 'new_dim' in actual.dims

# with coordinate

ind = DataArray(['a', 'b', 'c'], dims=['new_dim'],

coords={'new_dim': [0, 1, 2]})

actual = da.sel(x=ind)

self.assertArrayEqual(actual, da.isel(x=[0, 1, 2]))

assert 'new_dim' in actual.dims

assert 'new_dim' in actual.coords

self.assertDataArrayEqual(actual['new_dim'].drop('x'),

ind['new_dim'])

def test_sel_no_index(self):

array = DataArray(np.arange(10), dims='x')

self.assertDataArrayIdentical(array[0], array.sel(x=0))

self.assertDataArrayIdentical(array[:5], array.sel(x=slice(5)))

self.assertDataArrayIdentical(array[[0, -1]], array.sel(x=[0, -1]))

self.assertDataArrayIdentical(

array[array < 5], array.sel(x=(array < 5)))

def test_sel_method(self):

data = DataArray(np.random.randn(3, 4),

[('x', [0, 1, 2]), ('y', list('abcd'))])

expected = data.sel(y=['a', 'b'])

actual = data.sel(y=['ab', 'ba'], method='pad')

self.assertDataArrayIdentical(expected, actual)

expected = data.sel(x=[1, 2])

actual = data.sel(x=[0.9, 1.9], method='backfill', tolerance=1)

self.assertDataArrayIdentical(expected, actual)

def test_sel_drop(self):

data = DataArray([1, 2, 3], [('x', [0, 1, 2])])

expected = DataArray(1)

selected = data.sel(x=0, drop=True)

self.assertDataArrayIdentical(expected, selected)

expected = DataArray(1, {'x': 0})

selected = data.sel(x=0, drop=False)

self.assertDataArrayIdentical(expected, selected)

data = DataArray([1, 2, 3], dims=['x'])

expected = DataArray(1)

selected = data.sel(x=0, drop=True)

self.assertDataArrayIdentical(expected, selected)

def test_isel_drop(self):

data = DataArray([1, 2, 3], [('x', [0, 1, 2])])

expected = DataArray(1)

selected = data.isel(x=0, drop=True)