obsarray 0.2.5__tar.gz → 0.2.6__tar.gz

{obsarray-0.2.5 → obsarray-0.2.6}/.gitignore

@@ -77,7 +77,7 @@ instance/
 
 # Sphinx documentation
 docs/_build/
-docs/content/generated/
+docs/content/user/generated/
 
 # PyBuilder
 target/

{obsarray-0.2.5/obsarray.egg-info → obsarray-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: obsarray
-Version: 0.2.5
+Version: 0.2.6
 Summary: Measurement data handling in Python
 Home-page: https://github.com/comet-toolkit/obsarray
 Author: CoMet Toolkit Team

{obsarray-0.2.5 → obsarray-0.2.6}/obsarray/__init__.py

@@ -8,6 +8,7 @@ from obsarray import unc_accessor, flag_accessor
 from obsarray.err_corr import err_corr_forms
 from obsarray.templater.template_util import create_ds
 from obsarray.templater.dstemplater import DSTemplater
+from obsarray.templater.dswriter import DSWriter
 
 __version__ = get_versions()["version"]
 del get_versions

{obsarray-0.2.5 → obsarray-0.2.6}/obsarray/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-02-14T16:24:15+0000",
+ "date": "2024-03-26T17:59:27+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "a4c0efeceef26dd8201830bc88caab5689f25595",
- "version": "v0.2.5"
+ "full-revisionid": "3f90a44048e43a24a7ec1115d7b727944416ba9f",
+ "version": "v0.2.6"
 }
 '''  # END VERSION_JSON
 

{obsarray-0.2.5 → obsarray-0.2.6}/obsarray/err_corr.py

@@ -1,7 +1,7 @@
 """err_corr_forms - module for the defintion of error-correlation parameterisation forms"""
 
 import abc
-from typing import Callable, Type, Union
+from typing import Callable, Type, Union, List
 import numpy as np
 from comet_maths.linear_algebra.matrix_conversion import expand_errcorr_dims
 
@@ -69,23 +69,79 @@ class BaseErrCorrForm(abc.ABC):
         """Form name"""
         pass
 
-    def expand_dim_matrix(self, submatrix, sli):
+    def expand_dim_matrix(
+        self, submatrix: np.ndarray, submatrix_dim: Union[str, List[str]], sli: tuple
+    ):
         return expand_errcorr_dims(
             in_corr=submatrix,
-            in_dim=self.dims,
+            in_dim=submatrix_dim,
             out_dim=list(self._obj[self._unc_var_name][sli].dims),
-            dim_sizes={
-                dim: self._obj.dims[dim]
-                for dim in self._obj[self._unc_var_name][sli].dims
-            },
+            dim_sizes=self.get_sliced_dim_sizes_uncvar(sli),
         )
 
-    def slice_full_cov(self, full_matrix, sli):
-        mask_array = np.ones(self._obj[self._unc_var_name].shape, dtype=bool)
+    def get_sliced_dim_sizes_uncvar(self, sli: tuple) -> dict:
+        """
+        Return dictionary with sizes of sliced dimensions of unc variable, including all dimensions.
+
+        :param sli: slice (tuple with slice for each dimension)
+        :return: shape of included sliced dimensions
+        """
+        uncvar_dims = self._obj[self._unc_var_name][sli].dims
+        uncvar_shape = self._obj[self._unc_var_name][sli].shape
+        return {
+            uncvar_dims[idim]: uncvar_shape[idim] for idim in range(len(uncvar_dims))
+        }
+
+    def get_sliced_dim_sizes_errcorr(self, sli: tuple) -> dict:
+        """
+        Return dictionary with sizes of sliced dimensions of unc variable, including only dimensions which are
+        included in the current error correlation form.
+
+        :param sli: slice (tuple with slice for each dimension)
+        :return: shape of included sliced dimensions
+        """
+        uncvar_sizes = self.get_sliced_dim_sizes_uncvar(sli)
+        sliced_dims = self.get_sliced_dims_errcorr(sli)
+
+        return {dim: uncvar_sizes[dim] for dim in sliced_dims}
+
+    def get_sliced_dims_errcorr(self, sli: tuple) -> list:
+        """
+        Return dimensions which are within the slice and included in the current error correlation form.
+
+        :param sli: slice (tuple with slice for each dimension)
+        :return: list with sliced dimensions
+        """
+        all_dims = self._obj[self._unc_var_name].dims
+        return [
+            all_dims[idim]
+            for idim in range(len(all_dims))
+            if (isinstance(sli[idim], slice) and all_dims[idim] in self.dims)
+        ]
+
+    def get_sliced_shape_errcorr(self, sli: tuple) -> tuple:
+        """
+        return shape of sliced uncertainty variable, including only dimensions which are included in the current error correlation form.
+
+        :param sli: slice (tuple with slice for each dimension)
+        :return: shape of included sliced dimensions
+        """
+        uncvar_sizes = self.get_sliced_dim_sizes_uncvar(sli)
+        sliced_dims = self.get_sliced_dims_errcorr(sli)
+
+        return tuple([uncvar_sizes[dim] for dim in sliced_dims])
+
+    def slice_full_cov(self, full_matrix: np.ndarray, sli: tuple) -> np.ndarray:
+        return self.slice_flattened_matrix(
+            full_matrix, self._obj[self._unc_var_name].shape, sli
+        )
+
+    def slice_flattened_matrix(self, flattened_matrix, variable_shape, sli):
+        mask_array = np.ones(variable_shape, dtype=bool)
         mask_array[sli] = False
 
         return np.delete(
-            np.delete(full_matrix, mask_array.ravel(), 0), mask_array.ravel(), 1
+            np.delete(flattened_matrix, mask_array.ravel(), 0), mask_array.ravel(), 1
         )
 
     @abc.abstractmethod
@@ -100,6 +156,20 @@ class BaseErrCorrForm(abc.ABC):
         """
         pass
 
+    def build_dot_matrix(self, sli: Union[np.ndarray, tuple]) -> np.ndarray:
+        """
+        Returns uncertainty effect error-correlation matrix, populated with error-correlation values defined
+        in this parameterisation
+
+        :param sli: slice of observation variable to return error-correlation matrix for
+
+        :return: populated error-correlation matrix
+        """
+
+        return self.expand_dim_matrix(
+            self.build_matrix(sli), self.get_sliced_dims_errcorr(sli), sli
+        )
+
 
 def register_err_corr_form(form_name: str) -> Callable:
     """
@@ -122,7 +192,7 @@ class RandomCorrelation(BaseErrCorrForm):
     form = "random"
     is_random = True
 
-    def build_matrix(self, sli):
+    def build_matrix(self, sli: tuple) -> np.ndarray:
         """
         Returns uncertainty effect error-correlation matrix, populated with error-correlation values defined
         in this parameterisation
@@ -133,16 +203,12 @@ class RandomCorrelation(BaseErrCorrForm):
         """
 
         # evaluate correlation over matrices in form defintion
-        dim_lens = [len(self._obj[dim]) for dim in self.dims]
+        dim_lens = self.get_sliced_shape_errcorr(sli)
         n_elems = int(np.prod(dim_lens))
 
-        dims_matrix = np.eye(n_elems)
-
-        # expand to correlation matrix over all variable dims
-        return self.expand_dim_matrix(dims_matrix, sli)
+        submatrix = np.eye(n_elems)
 
-        # # subset to slice
-        # return self.slice_full_cov(full_matrix, sli)
+        return submatrix
 
 
 @register_err_corr_form("systematic")
@@ -151,7 +217,7 @@ class SystematicCorrelation(BaseErrCorrForm):
     form = "systematic"
     is_systematic = True
 
-    def build_matrix(self, sli):
+    def build_matrix(self, sli: tuple) -> np.ndarray:
         """
         Returns uncertainty effect error-correlation matrix, populated with error-correlation values defined
         in this parameterisation
@@ -162,16 +228,12 @@ class SystematicCorrelation(BaseErrCorrForm):
         """
 
         # evaluate correlation over matrices in form defintion
-        dim_lens = [len(self._obj[dim]) for dim in self.dims]
+        dim_lens = self.get_sliced_shape_errcorr(sli)
         n_elems = int(np.prod(dim_lens))
 
-        dims_matrix = np.ones((n_elems, n_elems))
-
-        # expand to correlation matrix over all variable dims
-        return self.expand_dim_matrix(dims_matrix, sli)
+        submatrix = np.ones((n_elems, n_elems))
 
-        # subset to slice
-        # return self.slice_full_cov(full_matrix, sli)
+        return submatrix
 
 
 @register_err_corr_form("err_corr_matrix")
@@ -179,7 +241,7 @@ class ErrCorrMatrixCorrelation(BaseErrCorrForm):
 
     form = "err_corr_matrix"
 
-    def build_matrix(self, sli):
+    def build_matrix(self, sli: tuple) -> np.ndarray:
         """
         Returns uncertainty effect error-correlation matrix, populated with error-correlation values defined
         in this parameterisation
@@ -189,11 +251,26 @@ class ErrCorrMatrixCorrelation(BaseErrCorrForm):
         :return: populated error-correlation matrix
         """
 
-        # expand to correlation matrix over all variable dims
-        return self.expand_dim_matrix(self._obj[self.params[0]], sli)
+        all_dims = self._obj[self._unc_var_name].dims
+        all_dims_sizes = self._obj.sizes
+
+        sli_submatrix = tuple(
+            [sli[i] for i in range(len(all_dims)) if all_dims[i] in self.dims]
+        )
+
+        sliced_shape = tuple(
+            [
+                all_dims_sizes[all_dims[i]]
+                for i in range(len(all_dims))
+                if all_dims[i] in self.dims
+            ]
+        )
+
+        submatrix = self.slice_flattened_matrix(
+            self._obj[self.params[0]], sliced_shape, sli_submatrix
+        )
 
-        # # subset to slice
-        # return self.slice_full_cov(full_matrix, sli)
+        return submatrix
 
 
 @register_err_corr_form("ensemble")
@@ -201,7 +278,7 @@ class EnsembleCorrelation(BaseErrCorrForm):
 
     form = "ensemble"
 
-    def build_matrix(self, sli):
+    def build_matrix(self, sli: tuple) -> np.ndarray:
         """
         Returns uncertainty effect error-correlation matrix, populated with error-correlation values defined
         in this parameterisation

{obsarray-0.2.5 → obsarray-0.2.6}/obsarray/flag_accessor.py

@@ -194,12 +194,12 @@ class FlagVariable:
         )
 
         if flag_meaning not in flag_meanings:
-            self._obj[
-                self._flag_var_name
-            ].attrs = DatasetUtil.add_flag_meaning_to_attrs(
-                self._obj[self._flag_var_name].attrs,
-                flag_meaning,
-                self._obj[self._flag_var_name].dtype,
+            self._obj[self._flag_var_name].attrs = (
+                DatasetUtil.add_flag_meaning_to_attrs(
+                    self._obj[self._flag_var_name].attrs,
+                    flag_meaning,
+                    self._obj[self._flag_var_name].dtype,
+                )
             )
 
         self[flag_meaning][:] = flag_value

{obsarray-0.2.5 → obsarray-0.2.6}/obsarray/templater/dataset_util.py

@@ -259,8 +259,8 @@ class DatasetUtil:
             attributes=attributes,
         )
 
-        #initialise flags to zero (instead of fillvalue)
-        variable.values=0*variable.values
+        # initialise flags to zero (instead of fillvalue)
+        variable.values = 0 * variable.values
 
         # add flag attributes
         variable.attrs.update(DatasetUtil.pack_flag_attrs(meanings))
@@ -290,7 +290,7 @@ class DatasetUtil:
         )
 
         if flag_masks is None:
-            flag_masks = [2 ** i for i in range(0, n_masks)]
+            flag_masks = [2**i for i in range(0, n_masks)]
 
         flag_attrs["flag_masks"] = str(flag_masks)[1:-1]
 
@@ -333,7 +333,7 @@ class DatasetUtil:
 
         # check if variable for available flags
         max_n_flags = numpy.iinfo(dtype).bits
-        all_flag_masks = [2 ** i for i in range(0, max_n_flags)]
+        all_flag_masks = [2**i for i in range(0, max_n_flags)]
         available_flag_masks = list(set(all_flag_masks) - set(flag_masks))
 
         if not available_flag_masks:
@@ -434,6 +434,10 @@ class DatasetUtil:
 
         if fill_value is not None:
             encoding_dict.update({"_FillValue": fill_value})
+        else:
+            encoding_dict.update(
+                {"_FillValue": DatasetUtil.get_default_fill_value(dtype)}
+            )
 
         variable.encoding = encoding_dict
 
@@ -524,8 +528,8 @@ class DatasetUtil:
 
         flags_ds = DatasetUtil.unpack_flags(da)
 
-        flags = flags if flags is not None else flags_ds.variables
-        mask_flags = [flags_ds[flag].values for flag in flags]
+        flags = flags if flags is not None else flags_ds.data_vars
+        mask_flags = numpy.array([flags_ds[flag].values for flag in flags])
 
         return numpy.logical_or.reduce(mask_flags)
 
@@ -546,8 +550,8 @@ class DatasetUtil:
 
         flags_ds = DatasetUtil.unpack_flags(da)
 
-        flags = flags if flags is not None else flags_ds.variables
-        mask_flags = [flags_ds[flag].values for flag in flags]
+        flags = flags if flags is not None else flags_ds.data_vars
+        mask_flags = numpy.array([flags_ds[flag].values for flag in flags])
 
         return numpy.logical_and.reduce(mask_flags)
 

{obsarray-0.2.5 → obsarray-0.2.6}/obsarray/templater/dswriter.py

@@ -81,7 +81,8 @@ class DSWriter:
                         )
                     }
                 )
-                ds[var_name].attrs.pop("_FillValue")
+                if "_FillValue" in ds[var_name].attrs:
+                    ds[var_name].attrs.pop("_FillValue")
             encoding.update({var_name: var_encoding})
 
         ds.to_netcdf(path, format="netCDF4", engine="netcdf4", encoding=encoding)

{obsarray-0.2.5 → obsarray-0.2.6}/obsarray/templater/template_util.py

@@ -159,6 +159,7 @@ class TemplateUtil:
 
             if "encoding" in var_attrs:
                 du.add_encoding(variable, **var_attrs["encoding"])
+                variable.attrs.pop("_FillValue")
 
         return variable
 

{obsarray-0.2.5 → obsarray-0.2.6}/obsarray/test/test_err_corr_forms.py

@@ -81,6 +81,59 @@ class TestBaseErrCorrForm(unittest.TestCase):
 
         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_flattened_matrix(self):
+        basicerrcorr = self.BasicErrCorrForm(
+            self.ds, "u_ran_temperature", ["x"], [], []
+        )
+
+        full_matrix = np.arange(144).reshape((12, 12))
+        slice_matrix = basicerrcorr.slice_flattened_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"], [], []
@@ -105,14 +158,14 @@ class TestRandomUnc(unittest.TestCase):
     def test_build_matrix_1stdim(self):
         rc = RandomCorrelation(self.ds, "u_ran_temperature", ["x"], [], [])
 
-        ecrm = rc.build_matrix((slice(None), slice(None), slice(None)))
+        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_matrix((slice(None), slice(None), slice(None)))
+        ecrm = rc.build_dot_matrix((slice(None), slice(None), slice(None)))
 
         np.testing.assert_equal(ecrm, np.eye(12))
 
@@ -124,7 +177,7 @@ class TestSystematicUnc(unittest.TestCase):
     def build_matrix_1stdim(self):
         rc = SystematicCorrelation(self.ds, "u_sys_temperature", ["x"], [], [])
 
-        ecrm = rc.build_matrix((slice(None), slice(None), slice(None)))
+        ecrm = rc.build_dot_matrix((slice(None), slice(None), slice(None)))
         # np.testing.assert_equal(ecrm, np.ones((12, 12)))
 
         return ecrm
@@ -132,7 +185,7 @@ class TestSystematicUnc(unittest.TestCase):
     def build_matrix_2nddim(self):
         rc = SystematicCorrelation(self.ds, "u_sys_temperature", ["y"], [], [])
 
-        ecrm = rc.build_matrix((slice(None), slice(None), slice(None)))
+        ecrm = rc.build_dot_matrix((slice(None), slice(None), slice(None)))
         # np.testing.assert_equal(ecrm, np.ones((12, 12)))
 
         return ecrm
@@ -140,15 +193,16 @@ class TestSystematicUnc(unittest.TestCase):
     def build_matrix_3ddim(self):
         rc = SystematicCorrelation(self.ds, "u_sys_temperature", ["time"], [], [])
 
-        ecrm = rc.build_matrix((slice(None), slice(None), slice(None)))
+        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_matrix(self):
+    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)))
 
 

{obsarray-0.2.5 → obsarray-0.2.6}/obsarray/test/test_flag_accessor.py

@@ -60,7 +60,7 @@ def create_ds():
     )
 
     ds["time_flags"] = create_var(
-        "temperature_flags",
+        "time_flags",
         {
             "dtype": "flag",
             "dim": ["time"],
@@ -83,7 +83,7 @@ class TestFlagAccessor(unittest.TestCase):
         self.assertEqual(self.ds.flag["general_flag"]._flag_var_name, "general_flag")
 
     def test___len__(self):
-        self.assertEqual(len(self.ds.flag), 2)
+        self.assertEqual(len(self.ds.flag), 3)
 
     def test___iter__(self):
 
@@ -92,11 +92,13 @@ class TestFlagAccessor(unittest.TestCase):
             self.assertIsInstance(flag, obsarray.flag_accessor.FlagVariable)
             var_names.append(flag._flag_var_name)
 
-        self.assertCountEqual(var_names, ["temperature_flags", "general_flags"])
+        self.assertCountEqual(
+            var_names, ["temperature_flags", "general_flags", "time_flags"]
+        )
 
     def test_keys(self):
         self.assertCountEqual(
-            self.ds.flag.keys(), ["temperature_flags", "general_flags"]
+            self.ds.flag.keys(), ["temperature_flags", "general_flags", "time_flags"]
         )
 
     def test__is_data_var_true(self):
@@ -117,7 +119,7 @@ class TestFlagAccessor(unittest.TestCase):
         self.assertEqual(type(flag_vars), xr.core.dataset.DataVariables)
         self.assertCountEqual(
             list(flag_vars.variables),
-            ["temperature_flags", "general_flags"],
+            ["temperature_flags", "general_flags", "time_flags"],
         )
 
     def test__is_flag_var_true(self):

{obsarray-0.2.5 → obsarray-0.2.6}/obsarray/test/test_unc_accessor.py

@@ -117,6 +117,11 @@ def create_ds():
         },
     )
 
+    ds["err_corr_str_temperature"] = (
+        ["x", "x"],
+        np.eye(temperature.shape[0]),
+    )
+
     return ds
 
 
@@ -474,13 +479,17 @@ class TestVariableUncertainty(unittest.TestCase):
         self.ds.unc["temperature"][:, :, 0].systematic_unc()
         mock.assert_called_once_with(["u_sys_temperature"])
 
-    @patch(
-        "obsarray.unc_accessor.Uncertainty.err_corr_matrix",
-        return_value=xr.DataArray(np.ones((12, 12)), dims=["x.y.time", "x.y.time"]),
-    )
-    def test_total_err_corr_matrix(self, mock_err_corr_matrix):
-        pass
-        # tercm = self.ds.unc["temperature"].total_err_corr_matrix()
+    def test_total_err_corr_matrix(
+        self,
+    ):
+        tercm = self.ds.unc["temperature"].total_err_corr_matrix()
+        assert tercm.shape == (12, 12)
+        tercm = self.ds.unc["temperature"][:, :, 0].total_err_corr_matrix()
+        assert tercm.shape == (4, 4)
+        tercm = self.ds.unc["temperature"][:, 0, 0:2].total_err_corr_matrix()
+        assert tercm.shape == (4, 4)
+        tercm = self.ds.unc["temperature"][0, 0, :].total_err_corr_matrix()
+        assert tercm.shape == (3, 3)
 
     def test_structured_err_corr_matrix(self):
         pass
@@ -496,7 +505,7 @@ class TestUncertainty(unittest.TestCase):
     def setUp(self):
         self.ds = create_ds()
 
-    @patch("obsarray.unc_accessor.Uncertainty.expand_sli", return_value="slice")
+    @patch("obsarray.unc_accessor.Uncertainty._expand_sli", return_value="slice")
     def test___getitem__(self, m):
         self.assertEqual(
             self.ds.unc["temperature"]["u_ran_temperature"]["in_slice"]._sli, "slice"
@@ -513,21 +522,30 @@ class TestUncertainty(unittest.TestCase):
     def test_expand_slice_1d_None(self):
         self.ds["new"] = (["time"], np.ones(3), {})
         self.ds.unc["new"]["u_new"] = (["time"], np.ones(3), {})
-        sli = self.ds.unc["temperature"]["u_ran_temperature"]._expand_sli()
+        sli = self.ds.unc["new"]["u_new"]._expand_sli()
         self.assertEqual((slice(None),), sli)
 
     def test_expand_slice_full(self):
-        sli = self.ds.unc["temperature"]["u_ran_temperature"].expand_sli((1, 1, 1))
+        sli = self.ds.unc["temperature"]["u_ran_temperature"]._expand_sli((1, 1, 1))
         self.assertEqual((1, 1, 1), sli)
 
     def test_expand_slice_None(self):
-        sli = self.ds.unc["temperature"]["u_ran_temperature"].expand_sli()
+        sli = self.ds.unc["temperature"]["u_ran_temperature"]._expand_sli()
         self.assertEqual((slice(None), slice(None), slice(None)), sli)
 
     def test_expand_slice_first(self):
-        sli = self.ds.unc["temperature"]["u_ran_temperature"].expand_sli((0,))
+        sli = self.ds.unc["temperature"]["u_ran_temperature"]._expand_sli((0,))
         self.assertEqual((0, slice(None), slice(None)), sli)
 
+    def test_rename(self):
+        ds = self.ds.unc["temperature"]["u_ran_temperature"].rename("test")
+        self.assertTrue("test" in ds.keys())
+        self.assertTrue("u_ran_temperature" not in ds.keys())
+        self.assertCountEqual(
+            ds["temperature"].attrs["unc_comps"],
+            ["test", "u_str_temperature", "u_sys_temperature"],
+        )
+
     def test_err_corr(self):
 
         expected_err_corr = [

{obsarray-0.2.5 → obsarray-0.2.6}/obsarray/unc_accessor.py

@@ -92,6 +92,20 @@ class Uncertainty:
 
         return out_sli
 
+    def rename(self, name) -> xr.Dataset:
+        """
+        Renames uncertainty variable and safely updates variable name references in obs variable metadata
+        :param name: desired name
+        :returns: dataset with safely renamed variable
+        """
+        self._obj = self._obj.rename({self._unc_var_name: name})
+        self._obj[self._var_name].attrs["unc_comps"] = [
+            v.replace(self._unc_var_name, name)
+            for v in self._obj[self._var_name].attrs["unc_comps"]
+        ]
+
+        return self._obj
+
     @property
     def err_corr(self) -> List[Tuple[Union[str, List[str]], BaseErrCorrForm]]:
         """
@@ -105,7 +119,9 @@ class Uncertainty:
         # Find dimensions in variable slice
         sli_dims = [
             dim
-            for dim, idx in zip(self._obj.dims.keys(), self._sli)
+            for dim, idx in zip(
+                self._obj.dims.keys(), self._sli
+            )  # Due to hit a FutureDeprecation warning
             if not isinstance(idx, int)
         ]
 
@@ -305,22 +321,6 @@ class Uncertainty:
                     )
         return err_corr_dict
 
-    def err_corr_dict_numdim(self) -> dict:
-        """
-        Error-correlation dictionary for uncertainty effect, where the keys are the dimension index rather than dimension name.
-
-        :return: dictionary with error-correlation for each dimension
-        """
-        # initialise error-correlation dictionary
-        err_corr_dict = self.err_corr_dict()
-        err_corr_dict_numdim = {}
-
-        for idim, dim in enumerate(self._obj.dims):
-            if dim in err_corr_dict.keys():
-                err_corr_dict_numdim[str(idim)] = err_corr_dict[dim]
-
-        return err_corr_dict_numdim
-
     def err_corr_matrix(self) -> xr.DataArray:
         """
         Error-correlation matrix for uncertainty effect.
@@ -336,14 +336,10 @@ class Uncertainty:
         # populate with error-correlation matrices built be each error-correlation
         # parameterisation object
         for dim_err_corr in self.err_corr:
-            if np.all(
-                [
-                    dim in self._obj[self._unc_var_name][self._sli].dims
-                    for dim in dim_err_corr[1].dims
-                ]
-            ):
+            sliced_dims = dim_err_corr[1].get_sliced_dims_errcorr(self._sli)
+            if len(dim_err_corr[1].get_sliced_dims_errcorr(self._sli)) > 0:
                 err_corr_matrix.values = err_corr_matrix.values.dot(
-                    dim_err_corr[1].build_matrix(self._sli)
+                    dim_err_corr[1].build_dot_matrix(self._sli)
                 )
 
         return err_corr_matrix
@@ -522,7 +518,7 @@ class VariableUncertainty:
                 quadsum_unc += self[unc_var_name].abs_value ** 2.0
 
         if quadsum_unc is not None:
-            quadsum_unc = quadsum_unc ** 0.5
+            quadsum_unc = quadsum_unc**0.5
 
         return quadsum_unc
 
@@ -824,7 +820,6 @@ class UncAccessor(object):
         """
 
         unc_var_names = self._var_unc_var_names(obs_var_name, unc_type=unc_type)
-
         if len(unc_var_names) == 0:
             return None
 

{obsarray-0.2.5 → obsarray-0.2.6/obsarray.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: obsarray
-Version: 0.2.5
+Version: 0.2.6
 Summary: Measurement data handling in Python
 Home-page: https://github.com/comet-toolkit/obsarray
 Author: CoMet Toolkit Team

{obsarray-0.2.5 → obsarray-0.2.6}/obsarray.egg-info/requires.txt

@@ -7,5 +7,6 @@ pre-commit
 tox
 sphinx
 sphinx_design
+sphinx_book_theme
 ipython
 sphinx_autosummary_accessors

{obsarray-0.2.5 → obsarray-0.2.6}/setup.py

@@ -9,7 +9,7 @@ import versioneer
 
 def read(filename):
     filename = os.path.join(os.path.dirname(__file__), filename)
-    text_type = type(u"")
+    text_type = type("")
     with io.open(filename, mode="r", encoding="utf-8") as fd:
         return re.sub(text_type(r":[a-z]+:`~?(.*?)`"), text_type(r"``\1``"), fd.read())
 
@@ -32,6 +32,7 @@ setup(
             "tox",
             "sphinx",
             "sphinx_design",
+            "sphinx_book_theme",
             "ipython",
             "sphinx_autosummary_accessors",
         ]