obsarray 1.0.2__py3-none-any.whl

obsarray/templater/tests/test_template_util.py

@@ -0,0 +1,334 @@
+"""
+Tests for TemplateUtil class
+"""
+
+import unittest
+from unittest.mock import patch, call
+import numpy as np
+import xarray
+from obsarray.templater.template_util import TemplateUtil, create_ds
+
+
+__author__ = "Sam Hunt <sam.hunt@npl.co.uk>"
+
+
+class TestTemplateUtil(unittest.TestCase):
+    @patch("obsarray.templater.template_util.DatasetUtil")
+    def test_add_variables_1var(self, mock_du):
+        dataset = xarray.Dataset()
+
+        size = {"dim1": 25, "dim2": 30, "dim3": 10, "dim4": 15}
+
+        template = {
+            "array_variable": {
+                "dim": ["dim1", "dim2"],
+                "dtype": np.float32,
+                "attributes": {
+                    "standard_name": "array_variable_std_name",
+                    "long_name": "array_variable_long_name",
+                    "units": "units",
+                    "preferred_symbol": "av",
+                },
+                "encoding": {"dtype": np.uint16, "scale_factor": 1.0, "offset": 0.0},
+            }
+        }
+
+        # run method
+        dataset = TemplateUtil.add_variables(dataset, template, size)
+
+        # test results
+        mock_du.return_value.create_variable.assert_called_once_with(
+            [25, 30],
+            dim_names=["dim1", "dim2"],
+            dtype=np.float32,
+            attributes={
+                "standard_name": "array_variable_std_name",
+                "long_name": "array_variable_long_name",
+                "units": "units",
+                "preferred_symbol": "av",
+            },
+        )
+        mock_du.return_value.add_encoding.assert_called_once_with(
+            mock_du.return_value.create_variable.return_value,
+            dtype=np.uint16,
+            scale_factor=1.0,
+            offset=0.0,
+        )
+
+    @patch("obsarray.templater.template_util.DatasetUtil")
+    def test_add_variables_1uncvar(self, mock_du):
+        dataset = xarray.Dataset()
+
+        size = {"dim1": 25, "dim2": 30, "dim3": 10, "dim4": 15}
+
+        template = {
+            "array_variable": {
+                "dim": ["dim1", "dim2"],
+                "dtype": np.float32,
+                "attributes": {
+                    "standard_name": "array_variable_std_name",
+                    "long_name": "array_variable_long_name",
+                    "units": "units",
+                    "preferred_symbol": "av",
+                    "err_corr": "err_corr",
+                },
+                "encoding": {"dtype": np.uint16, "scale_factor": 1.0, "offset": 0.0},
+            }
+        }
+
+        # run method
+        dataset = TemplateUtil.add_variables(dataset, template, size)
+
+        # test results
+        mock_du.return_value.create_unc_variable.assert_called_once_with(
+            [25, 30],
+            dim_names=["dim1", "dim2"],
+            dtype=np.float32,
+            attributes={
+                "standard_name": "array_variable_std_name",
+                "long_name": "array_variable_long_name",
+                "units": "units",
+                "preferred_symbol": "av",
+            },
+            err_corr="err_corr",
+        )
+        mock_du.return_value.add_encoding.assert_called_once_with(
+            mock_du.return_value.create_unc_variable.return_value,
+            dtype=np.uint16,
+            scale_factor=1.0,
+            offset=0.0,
+        )
+
+    @patch("obsarray.templater.template_util.DatasetUtil")
+    def test_add_variables_1flag(self, mock_du):
+        dataset = xarray.Dataset()
+
+        dim_sizes = {"dim1": 25, "dim2": 30, "dim3": 10, "dim4": 15}
+
+        test_variables = {
+            "array_variable": {
+                "dim": ["dim1", "dim2"],
+                "dtype": "flag",
+                "attributes": {
+                    "standard_name": "array_variable_std_name",
+                    "long_name": "array_variable_long_name",
+                    "preferred_symbol": "av",
+                    "flag_meanings": ["flag1"],
+                },
+            }
+        }
+
+        # run method
+        dataset = TemplateUtil.add_variables(dataset, test_variables, dim_sizes)
+
+        # test results
+        mock_du.return_value.create_flags_variable.assert_called_once_with(
+            [25, 30],
+            dim_names=["dim1", "dim2"],
+            meanings=["flag1"],
+            attributes={
+                "standard_name": "array_variable_std_name",
+                "long_name": "array_variable_long_name",
+                "preferred_symbol": "av",
+            },
+        )
+
+    @patch("obsarray.templater.template_util.DatasetUtil")
+    def test_add_variables_2var(self, mock_du):
+        dataset = xarray.Dataset()
+
+        size = {"dim1": 25, "dim2": 30, "dim3": 10, "dim4": 15}
+
+        template = {
+            "array_variable1": {
+                "dim": ["dim1", "dim2"],
+                "dtype": np.float32,
+                "attributes": {
+                    "standard_name": "array_variable_std_name1",
+                    "long_name": "array_variable_long_name1",
+                    "units": "units",
+                    "preferred_symbol": "av",
+                },
+                "encoding": {"dtype": np.uint16, "scale_factor": 1.0, "offset": 0.0},
+            },
+            "array_variable2": {
+                "dim": ["dim3", "dim4"],
+                "dtype": np.float32,
+                "attributes": {
+                    "standard_name": "array_variable_std_name2",
+                    "long_name": "array_variable_long_name2",
+                    "units": "units",
+                    "preferred_symbol": "av",
+                },
+                "encoding": {"dtype": np.uint16, "scale_factor": 1.0, "offset": 0.0},
+            },
+        }
+
+        # run method
+        dataset = TemplateUtil.add_variables(dataset, template, size)
+
+        # test results
+        # define expected calls to DatasetUtil methods
+        calls = [
+            call(
+                [25, 30],
+                dim_names=["dim1", "dim2"],
+                dtype=np.float32,
+                attributes={
+                    "standard_name": "array_variable_std_name1",
+                    "long_name": "array_variable_long_name1",
+                    "units": "units",
+                    "preferred_symbol": "av",
+                },
+            ),
+            call(
+                [10, 15],
+                dim_names=["dim3", "dim4"],
+                dtype=np.float32,
+                attributes={
+                    "standard_name": "array_variable_std_name2",
+                    "long_name": "array_variable_long_name2",
+                    "units": "units",
+                    "preferred_symbol": "av",
+                },
+            ),
+        ]
+
+        mock_du.return_value.create_variable.assert_has_calls(calls, any_order=True)
+
+    def test_add_variables_1var_ds(self):
+        dataset = xarray.Dataset()
+
+        size = {"dim1": 25, "dim2": 30, "dim3": 10, "dim4": 15}
+
+        template = {
+            "array_variable": {
+                "dim": ["dim1", "dim2"],
+                "dtype": np.float32,
+                "attributes": {
+                    "standard_name": "array_variable_std_name",
+                    "long_name": "array_variable_long_name",
+                    "units": "units",
+                    "preferred_symbol": "av",
+                },
+                "encoding": {"dtype": np.uint16, "scale_factor": 1.0, "offset": 0.0},
+            }
+        }
+
+        # run method
+        dataset = TemplateUtil.add_variables(dataset, template, size)
+
+        # assert dataset with variables
+        self.assertEqual(type(dataset), xarray.Dataset)
+        self.assertEqual(type(dataset["array_variable"]), xarray.DataArray)
+
+    def test__return_variable_shape(self):
+        size = {"dim1": 25, "dim2": 30, "dim3": 10, "dim4": 15}
+        dim_names = ["dim2", "dim1"]
+
+        dim_sizes = TemplateUtil._return_variable_shape(dim_names=dim_names, size=size)
+
+        self.assertCountEqual([30, 25], dim_sizes)
+
+    def test__check_variable_definition_bad_name(self):
+        test_variable_name = 23
+        test_variable_attrs = {
+            "dim": ["dim1", "dim2"],
+            "dtype": np.float32,
+            "attributes": {
+                "standard_name": "array_variable_std_name",
+                "long_name": "array_variable_long_name",
+                "units": "units",
+                "preferred_symbol": "av",
+            },
+            "encoding": {"dtype": np.uint16, "scale_factor": 1.0, "offset": 0.0},
+        }
+
+        self.assertRaises(
+            TypeError,
+            TemplateUtil._check_variable_definition,
+            test_variable_name,
+            test_variable_attrs,
+        )
+
+    def test_add_metadata(self):
+        dataset = xarray.Dataset()
+
+        test_metadata = {"metadata1": "value"}
+
+        TemplateUtil.add_metadata(dataset, test_metadata)
+
+        self.assertEqual("value", dataset.attrs["metadata1"])
+
+    def test_create_template_dataset(self):
+        dim_sizes = {"dim1": 25, "dim2": 30, "dim3": 10, "dim4": 15}
+
+        test_variables = {
+            "array_variable": {
+                "dim": ["dim1", "dim2"],
+                "dtype": np.float32,
+                "attributes": {
+                    "standard_name": "array_variable_std_name",
+                    "long_name": "array_variable_long_name",
+                    "units": "units",
+                    "preferred_symbol": "av",
+                },
+                "encoding": {"dtype": np.uint16, "scale_factor": 1.0, "offset": 0.0},
+            }
+        }
+
+        test_metadata = {"metadata1": "value"}
+
+        ds = create_ds(test_variables, dim_sizes, test_metadata)
+
+        self.assertEqual(type(ds), xarray.Dataset)
+        self.assertEqual(type(ds["array_variable"]), xarray.DataArray)
+        self.assertEqual("value", ds.attrs["metadata1"])
+
+    def test_create_template_dataset_withunc(self):
+        dim_sizes = {"dim1": 25}
+
+        test_variables = {
+            "array_variable": {
+                "dim": ["dim1"],
+                "dtype": np.float32,
+                "attributes": {
+                    "standard_name": "array_variable_std_name",
+                    "long_name": "array_variable_long_name",
+                    "units": "units",
+                    "preferred_symbol": "av",
+                    "unc_comps": ["u_array_variable"],
+                },
+                "encoding": {"dtype": np.uint16, "scale_factor": 1.0, "offset": 0.0},
+            },
+            "u_array_variable": {
+                "dim": ["dim1"],
+                "dtype": np.float32,
+                "attributes": {
+                    "err_corr": [
+                        {
+                            "dim": ["dim1"],
+                            "form": "rectangle_absolute",
+                            "params": [1, 2],
+                            "units": ["m", "m"],
+                        },
+                    ],
+                    "standard_name": "array_variable_std_name",
+                    "long_name": "array_variable_long_name",
+                    "units": "units",
+                    "preferred_symbol": "av",
+                },
+            },
+        }
+
+        test_metadata = {"metadata1": "value"}
+
+        ds = create_ds(test_variables, dim_sizes, test_metadata)
+
+        self.assertEqual(type(ds), xarray.Dataset)
+        self.assertEqual(type(ds["array_variable"]), xarray.DataArray)
+        self.assertEqual("value", ds.attrs["metadata1"])
+
+
+if __name__ == "__main__":
+    unittest.main()

obsarray/test/test_err_corr_forms.py

@@ -0,0 +1,251 @@
+"""test_err_corr_forms - tests for obsarray.err_corr_forms"""
+
+import unittest
+import numpy as np
+from obsarray.err_corr import (
+    BaseErrCorrForm,
+    ErrCorrForms,
+    RandomCorrelation,
+    SystematicCorrelation,
+    ErrCorrMatrixCorrelation,
+)
+from obsarray.test.test_unc_accessor import create_ds
+
+__author__ = "Sam Hunt <sam.hunt@npl.co.uk>"
+__all__ = []
+
+
+class TestErrCorrForms(unittest.TestCase):
+    def setUp(self):
+        class ErrCorrFormDef(BaseErrCorrForm):
+            def form(self):
+                pass
+
+        self.ErrCorrFormDef = ErrCorrFormDef
+
+    def test___setitem__(self):
+        err_corr_forms = ErrCorrForms()
+        err_corr_forms["test"] = self.ErrCorrFormDef
+
+        self.assertCountEqual(list(err_corr_forms._forms.keys()), ["test"])
+
+    def test___setitem___not_valid_cls(self):
+        class InvalidErrCorrFormDef:
+            pass
+
+        err_corr_forms = ErrCorrForms()
+        self.assertRaises(
+            TypeError, err_corr_forms.__setitem__, "test", InvalidErrCorrFormDef
+        )
+
+    def test___getitem__(self):
+        err_corr_forms = ErrCorrForms()
+        err_corr_forms._forms["test"] = "test"
+        self.assertEqual("test", err_corr_forms["test"])
+
+    def test___delitem__(self):
+        err_corr_forms = ErrCorrForms()
+        err_corr_forms._forms["test"] = "test"
+
+        del err_corr_forms._forms["test"]
+
+        self.assertTrue("test" not in err_corr_forms._forms)
+
+    def test_keys(self):
+        err_corr_forms = ErrCorrForms()
+        err_corr_forms._forms["test"] = "test"
+
+        self.assertCountEqual(["test"], err_corr_forms.keys())
+
+
+class TestBaseErrCorrForm(unittest.TestCase):
+    def setUp(self) -> None:
+        self.ds = create_ds()
+
+        class BasicErrCorrForm(BaseErrCorrForm):
+            form = "basic"
+
+            def build_matrix(self, sli):
+                full_matrix = np.arange(144).reshape((12, 12))
+                return self.slice_errcorr_matrix(full_matrix, (2, 2, 3), sli)
+
+        self.BasicErrCorrForm = BasicErrCorrForm
+
+    def test_get_varshape_errcorr(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x", "y", "time"], [], []
+        )
+        shape = basicerrcorr.get_varshape_errcorr()
+        np.testing.assert_equal(shape, (2, 2, 3))
+
+    def test_slice_full_cov_full(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x"], [], []
+        )
+
+        full_matrix = np.arange(144).reshape((12, 12))
+        slice_matrix = basicerrcorr.build_matrix(
+            (slice(None), slice(None), slice(None))
+        )
+
+        np.testing.assert_equal(full_matrix, slice_matrix)
+
+    def test_get_sliced_dim_sizes_uncvar(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x"], [], []
+        )
+        dim_sizes = basicerrcorr.get_sliced_dim_sizes_uncvar(
+            (slice(None), 0, slice(0, 2, 1))
+        )
+        assert dim_sizes == {"x": 2, "time": 2}
+
+    def test_get_sliced_dim_sizes_errcorr(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x"], [], []
+        )
+        dim_sizes = basicerrcorr.get_sliced_dim_sizes_errcorr(
+            (slice(None), 0, slice(0, 2, 1))
+        )
+        assert dim_sizes == {"x": 2}
+
+    def test_get_sliced_dims_errcorr(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x"], [], []
+        )
+        dims = basicerrcorr.get_sliced_dims_errcorr((slice(None), 0, slice(0, 2, 1)))
+        assert dims == ["x"]
+
+    def test_get_sliced_shape_errcorr(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x"], [], []
+        )
+        shape = basicerrcorr.get_sliced_shape_errcorr((slice(None), 0, slice(0, 2, 1)))
+        assert shape == (2,)
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x", "time"], [], []
+        )
+        shape = basicerrcorr.get_sliced_shape_errcorr((slice(None), 0, slice(0, 2, 1)))
+        assert shape == (2, 2)
+
+    def test_slice_errcorr_matrix(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x", "y", "z"], [], []
+        )
+
+        full_matrix = np.arange(144).reshape((12, 12))
+        slice_matrix = basicerrcorr.slice_errcorr_matrix(
+            full_matrix, (2, 2, 3), (slice(None), slice(None), 0)
+        )
+
+        exp_slice_matrix = np.array(
+            [[0, 3, 6, 9], [36, 39, 42, 45], [72, 75, 78, 81], [108, 111, 114, 117]]
+        )
+
+        np.testing.assert_equal(slice_matrix, exp_slice_matrix)
+
+    def test_slice_full_cov_slice(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x", "y", "z"], [], []
+        )
+
+        slice_matrix = basicerrcorr.build_dot_matrix((slice(None), slice(None), 0))
+
+        exp_slice_matrix = np.array(
+            [[0, 3, 6, 9], [36, 39, 42, 45], [72, 75, 78, 81], [108, 111, 114, 117]]
+        )
+
+        np.testing.assert_equal(slice_matrix, exp_slice_matrix)
+
+
+class TestRandomUnc(unittest.TestCase):
+    def setUp(self) -> None:
+        self.ds = create_ds()
+
+    def test_build_matrix_1stdim(self):
+        rc = RandomCorrelation(self.ds, "u_ran_temperature", ["x"], [], [])
+
+        ecrm = rc.build_dot_matrix((slice(None), slice(None), slice(None)))
+
+        np.testing.assert_equal(ecrm, np.eye(12))
+
+    def test_build_matrix_2nddim(self):
+        rc = RandomCorrelation(self.ds, "u_ran_temperature", ["y"], [], [])
+
+        ecrm = rc.build_dot_matrix((slice(None), slice(None), slice(None)))
+
+        np.testing.assert_equal(ecrm, np.eye(12))
+
+
+class TestSystematicUnc(unittest.TestCase):
+    def setUp(self) -> None:
+        self.ds = create_ds()
+
+    def build_matrix_1stdim(self):
+        rc = SystematicCorrelation(self.ds, "u_sys_temperature", ["x"], [], [])
+
+        ecrm = rc.build_dot_matrix((slice(None), slice(None), slice(None)))
+        # np.testing.assert_equal(ecrm, np.ones((12, 12)))
+
+        return ecrm
+
+    def build_matrix_2nddim(self):
+        rc = SystematicCorrelation(self.ds, "u_sys_temperature", ["y"], [], [])
+
+        ecrm = rc.build_dot_matrix((slice(None), slice(None), slice(None)))
+        # np.testing.assert_equal(ecrm, np.ones((12, 12)))
+
+        return ecrm
+
+    def build_matrix_3ddim(self):
+        rc = SystematicCorrelation(self.ds, "u_sys_temperature", ["time"], [], [])
+
+        ecrm = rc.build_dot_matrix((slice(None), slice(None), slice(None)))
+        # np.testing.assert_equal(ecrm, np.ones((12, 12)))
+
+        return ecrm
+
+    def test_build_dot_matrix(self):
+        x = self.build_matrix_1stdim()
+        y = self.build_matrix_2nddim()
+        time = self.build_matrix_3ddim()
+        print(x.dot(y), x, y)
+        np.testing.assert_equal((x.dot(y)).dot(time), np.ones((12, 12)))
+
+
+class TestErrCorrMatrixCorrelation(unittest.TestCase):
+    def setUp(self) -> None:
+        self.ds = create_ds()
+
+    def test_build_matrix_full(self):
+        ec = ErrCorrMatrixCorrelation(
+            self.ds,
+            "u_str_temperature",
+            ["x", "time"],
+            ["err_corr_str_temperature"],
+            [],
+        )
+
+        ecrm = ec.build_matrix((slice(None), slice(None), slice(None)))
+        np.testing.assert_equal(ecrm, np.ones((6, 6)))
+
+    def test_build_matrix_sliced(self):
+        ec = ErrCorrMatrixCorrelation(
+            self.ds,
+            "u_str_temperature",
+            ["x", "time"],
+            ["err_corr_str_temperature"],
+            [],
+        )
+
+        ecrm = ec.build_matrix((0, slice(None), slice(None)))
+        np.testing.assert_equal(ecrm, np.ones((3, 3)))
+
+        ecrm = ec.build_matrix((slice(None), 0, slice(None)))
+        np.testing.assert_equal(ecrm, np.ones((6, 6)))
+
+        ecrm = ec.build_matrix((slice(None), slice(None), 0))
+        np.testing.assert_equal(ecrm, np.ones((2, 2)))
+
+
+if __name__ == "main":
+    unittest.main()