Python xarray.Variable类代码示例

    def test_stack_errors(self):
        v = Variable(["x", "y"], [[0, 1], [2, 3]], {"foo": "bar"})

        with self.assertRaisesRegexp(ValueError, "invalid existing dim"):
            v.stack(z=("x1",))
        with self.assertRaisesRegexp(ValueError, "cannot create a new dim"):
            v.stack(x=("x",))

 def test_items(self):
     data = np.random.random((10, 11))
     v = Variable(['x', 'y'], data)
     # test slicing
     self.assertVariableIdentical(v, v[:])
     self.assertVariableIdentical(v, v[...])
     self.assertVariableIdentical(Variable(['y'], data[0]), v[0])
     self.assertVariableIdentical(Variable(['x'], data[:, 0]), v[:, 0])
     self.assertVariableIdentical(Variable(['x', 'y'], data[:3, :2]),
                                  v[:3, :2])
     # test array indexing
     x = Variable(['x'], np.arange(10))
     y = Variable(['y'], np.arange(11))
     self.assertVariableIdentical(v, v[x.values])
     self.assertVariableIdentical(v, v[x])
     self.assertVariableIdentical(v[:3], v[x < 3])
     self.assertVariableIdentical(v[:, 3:], v[:, y >= 3])
     self.assertVariableIdentical(v[:3, 3:], v[x < 3, y >= 3])
     self.assertVariableIdentical(v[:3, :2], v[x[:3], y[:2]])
     self.assertVariableIdentical(v[:3, :2], v[range(3), range(2)])
     # test iteration
     for n, item in enumerate(v):
         self.assertVariableIdentical(Variable(['y'], data[n]), item)
     with self.assertRaisesRegexp(TypeError, 'iteration over a 0-d'):
         iter(Variable([], 0))
     # test setting
     v.values[:] = 0
     self.assertTrue(np.all(v.values == 0))
     # test orthogonal setting
     v[range(10), range(11)] = 1
     self.assertArrayEqual(v.values, np.ones((10, 11)))

 def test_concat(self):
     u = self.eager_var
     v = self.lazy_var
     self.assertLazyAndIdentical(u, Variable.concat([v[:2], v[2:]], 'x'))
     self.assertLazyAndIdentical(u[:2], Variable.concat([v[0], v[1]], 'x'))
     self.assertLazyAndIdentical(
         u[:3], Variable.concat([v[[0, 2]], v[[1]]], 'x', positions=[[0, 2], [1]]))

def test_outer_indexer_consistency_with_broadcast_indexes_vectorized():
    def nonzero(x):
        if isinstance(x, np.ndarray) and x.dtype.kind == 'b':
            x = x.nonzero()[0]
        return x

    original = np.random.rand(10, 20, 30)
    v = Variable(['i', 'j', 'k'], original)
    I = ReturnItem()  # noqa: E741  # allow ambiguous name
    # test orthogonally applied indexers
    indexers = [I[:], 0, -2, I[:3], np.array([0, 1, 2, 3]), np.array([0]),
                np.arange(10) < 5]
    for i, j, k in itertools.product(indexers, repeat=3):

        if isinstance(j, np.ndarray) and j.dtype.kind == 'b':  # match size
            j = np.arange(20) < 4
        if isinstance(k, np.ndarray) and k.dtype.kind == 'b':
            k = np.arange(30) < 8

        _, expected, new_order = v._broadcast_indexes_vectorized((i, j, k))
        expected_data = nputils.NumpyVIndexAdapter(v.data)[expected.tuple]
        if new_order:
            old_order = range(len(new_order))
            expected_data = np.moveaxis(expected_data, old_order,
                                        new_order)

        outer_index = indexing.OuterIndexer((nonzero(i), nonzero(j),
                                             nonzero(k)))
        actual = indexing._outer_to_numpy_indexer(outer_index, v.shape)
        actual_data = v.data[actual]
        np.testing.assert_array_equal(actual_data, expected_data)

    def test_numpy_same_methods(self):
        v = Variable([], np.float32(0.0))
        self.assertEqual(v.item(), 0)
        self.assertIs(type(v.item()), float)

        v = Coordinate('x', np.arange(5))
        self.assertEqual(2, v.searchsorted(2))

    def test_roll_consistency(self):
        v = Variable(('x', 'y'), np.random.randn(5, 6))

        for axis, dim in [(0, 'x'), (1, 'y')]:
            for shift in [-3, 0, 1, 7, 11]:
                expected = np.roll(v.values, shift, axis=axis)
                actual = v.roll(**{dim: shift}).values
                self.assertArrayEqual(expected, actual)

 def test_expand_dims_object_dtype(self):
     v = Variable([], ("a", 1))
     actual = v.expand_dims(("x",), (3,))
     exp_values = np.empty((3,), dtype=object)
     for i in range(3):
         exp_values[i] = ("a", 1)
     expected = Variable(["x"], exp_values)
     assert actual.identical(expected)

    def test_unstack_2d(self):
        v = Variable(["x", "y"], [[0, 1], [2, 3]])
        actual = v.unstack(y={"z": 2})
        expected = Variable(["x", "z"], v.data)
        self.assertVariableIdentical(actual, expected)

        actual = v.unstack(x={"z": 2})
        expected = Variable(["y", "z"], v.data.T)
        self.assertVariableIdentical(actual, expected)

 def test_concat_attrs(self):
     # different or conflicting attributes should be removed
     v = self.cls('a', np.arange(5), {'foo': 'bar'})
     w = self.cls('a', np.ones(5))
     expected = self.cls('a', np.concatenate([np.arange(5), np.ones(5)]))
     self.assertVariableIdentical(expected, Variable.concat([v, w], 'a'))
     w.attrs['foo'] = 2
     self.assertVariableIdentical(expected, Variable.concat([v, w], 'a'))
     w.attrs['foo'] = 'bar'
     expected.attrs['foo'] = 'bar'
     self.assertVariableIdentical(expected, Variable.concat([v, w], 'a'))

 def test_variable_pickle(self):
     # Test that pickling/unpickling does not convert the dask
     # backend to numpy
     a1 = Variable(['x'], build_dask_array())
     a1.compute()
     self.assertFalse(a1._in_memory)
     self.assertEquals(kernel_call_count, 1)
     a2 = pickle.loads(pickle.dumps(a1))
     self.assertEquals(kernel_call_count, 1)
     self.assertVariableIdentical(a1, a2)
     self.assertFalse(a1._in_memory)
     self.assertFalse(a2._in_memory)

 def test_pickle(self):
     # Test that pickling/unpickling does not convert the dask
     # backend to numpy
     a1 = Variable(['x'], build_dask_array('x'))
     a1.compute()
     assert not a1._in_memory
     assert kernel_call_count == 1
     a2 = pickle.loads(pickle.dumps(a1))
     assert kernel_call_count == 1
     assert_identical(a1, a2)
     assert not a1._in_memory
     assert not a2._in_memory

    def test_unstack(self):
        v = Variable("z", [0, 1, 2, 3], {"foo": "bar"})
        actual = v.unstack(z=OrderedDict([("x", 2), ("y", 2)]))
        expected = Variable(("x", "y"), [[0, 1], [2, 3]], v.attrs)
        self.assertVariableIdentical(actual, expected)

        actual = v.unstack(z=OrderedDict([("x", 4), ("y", 1)]))
        expected = Variable(("x", "y"), [[0], [1], [2], [3]], v.attrs)
        self.assertVariableIdentical(actual, expected)

        actual = v.unstack(z=OrderedDict([("x", 4)]))
        expected = Variable("x", [0, 1, 2, 3], v.attrs)
        self.assertVariableIdentical(actual, expected)

 def test_transpose(self):
     v = Variable(['time', 'x'], self.d)
     v2 = Variable(['x', 'time'], self.d.T)
     self.assertVariableIdentical(v, v2.transpose())
     self.assertVariableIdentical(v.transpose(), v.T)
     x = np.random.randn(2, 3, 4, 5)
     w = Variable(['a', 'b', 'c', 'd'], x)
     w2 = Variable(['d', 'b', 'c', 'a'], np.einsum('abcd->dbca', x))
     self.assertEqual(w2.shape, (5, 3, 4, 2))
     self.assertVariableIdentical(w2, w.transpose('d', 'b', 'c', 'a'))
     self.assertVariableIdentical(w, w2.transpose('a', 'b', 'c', 'd'))
     w3 = Variable(['b', 'c', 'd', 'a'], np.einsum('abcd->bcda', x))
     self.assertVariableIdentical(w, w3.transpose('a', 'b', 'c', 'd'))

    def test_reduce_keep_attrs(self):
        _attrs = {"units": "test", "long_name": "testing"}

        v = Variable(["x", "y"], self.d, _attrs)

        # Test dropped attrs
        vm = v.mean()
        self.assertEqual(len(vm.attrs), 0)
        self.assertEqual(vm.attrs, OrderedDict())

        # Test kept attrs
        vm = v.mean(keep_attrs=True)
        self.assertEqual(len(vm.attrs), len(_attrs))
        self.assertEqual(vm.attrs, _attrs)

 def test_data_and_values(self):
     v = Variable(['time', 'x'], self.d)
     self.assertArrayEqual(v.data, self.d)
     self.assertArrayEqual(v.values, self.d)
     self.assertIs(source_ndarray(v.values), self.d)
     with self.assertRaises(ValueError):
         # wrong size
         v.values = np.random.random(5)
     d2 = np.random.random((10, 3))
     v.values = d2
     self.assertIs(source_ndarray(v.values), d2)
     d3 = np.random.random((10, 3))
     v.data = d3
     self.assertIs(source_ndarray(v.data), d3)