Python xray.Variable类代码示例

    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_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 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']

    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_data(self):
     v = Variable(['time', 'x'], 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)

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

    def test_count(self):
        expected = Variable([], 3)
        actual = Variable(['x'], [1, 2, 3, np.nan]).count()
        self.assertVariableIdentical(expected, actual)

        v = Variable(['x'], np.array(['1', '2', '3', np.nan], dtype=object))
        actual = v.count()
        self.assertVariableIdentical(expected, actual)

        actual = Variable(['x'], [True, False, True]).count()
        self.assertVariableIdentical(expected, actual)
        self.assertEqual(actual.dtype, int)

        expected = Variable(['x'], [2, 3])
        actual = Variable(['x', 'y'], [[1, 0, np.nan], [1, 1, 1]]).count('y')
        self.assertVariableIdentical(expected, actual)

    def test_broadcast_equals(self):
        v1 = Variable((), np.nan)
        v2 = Variable(('x'), [np.nan, np.nan])
        self.assertTrue(v1.broadcast_equals(v2))
        self.assertFalse(v1.equals(v2))
        self.assertFalse(v1.identical(v2))

        v3 = Variable(('x'), [np.nan])
        self.assertTrue(v1.broadcast_equals(v3))
        self.assertFalse(v1.equals(v3))
        self.assertFalse(v1.identical(v3))

        self.assertFalse(v1.broadcast_equals(None))

        v4 = Variable(('x'), [np.nan] * 3)
        self.assertFalse(v2.broadcast_equals(v4))

    def test_roll(self):
        v = Variable("x", [1, 2, 3, 4, 5])

        self.assertVariableIdentical(v, v.roll(x=0))
        self.assertIsNot(v, v.roll(x=0))

        expected = Variable("x", [5, 1, 2, 3, 4])
        self.assertVariableIdentical(expected, v.roll(x=1))
        self.assertVariableIdentical(expected, v.roll(x=-4))
        self.assertVariableIdentical(expected, v.roll(x=6))

        expected = Variable("x", [4, 5, 1, 2, 3])
        self.assertVariableIdentical(expected, v.roll(x=2))
        self.assertVariableIdentical(expected, v.roll(x=-3))

        with self.assertRaisesRegexp(ValueError, "dimension"):
            v.roll(z=0)

 def test_concat_fixed_len_str(self):
     # regression test for #217
     for kind in ["S", "U"]:
         x = self.cls("animal", np.array(["horse"], dtype=kind))
         y = self.cls("animal", np.array(["aardvark"], dtype=kind))
         actual = Variable.concat([x, y], "animal")
         expected = Variable("animal", np.array(["horse", "aardvark"], dtype=kind))
         self.assertVariableEqual(expected, actual)

 def test_concat_number_strings(self):
     # regression test for #305
     a = self.cls("x", ["0", "1", "2"])
     b = self.cls("x", ["3", "4"])
     actual = Variable.concat([a, b], dim="x")
     expected = Variable("x", np.arange(5).astype(str).astype(object))
     self.assertVariableIdentical(expected, actual)
     self.assertEqual(expected.dtype, object)
     self.assertEqual(type(expected.values[0]), str)