obsarray 1.0.2__tar.gz → 1.0.3__tar.gz

{obsarray-1.0.2/obsarray.egg-info → obsarray-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: obsarray
-Version: 1.0.2
+Version: 1.0.3
 Summary: Measurement data handling in Python
 Author-email: CoMet Toolkit Team <team@comet-toolkit.org>
 Project-URL: Homepage, https://github.com/comet-toolkit/obsarray

{obsarray-1.0.2 → obsarray-1.0.3}/obsarray/__init__.py

@@ -9,6 +9,7 @@ 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
+from obsarray.utils import append_names
 
 __version__ = get_versions()["version"]
 del get_versions

{obsarray-1.0.2 → obsarray-1.0.3}/obsarray/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-04-25T14:06:04+0100",
+ "date": "2025-06-22T11:46:36+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "b26b43a5d2e41ccb9a5e73c00e6d16a28a8515a9",
- "version": "1.0.2"
+ "full-revisionid": "48598121962220e8e42df0515693a450e732585c",
+ "version": "1.0.3"
 }
 '''  # END VERSION_JSON
 

{obsarray-1.0.2 → obsarray-1.0.3}/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-1.0.2 → obsarray-1.0.3}/obsarray/templater/dataset_util.py

@@ -507,7 +507,7 @@ class DatasetUtil:
             ds[flag_meaning] = DatasetUtil.create_variable(
                 list(da.shape), bool, dim_names=list(da.dims)
             )
-            ds[flag_meaning] = (da & flag_mask).astype(bool)
+            ds[flag_meaning] = (da.astype(int) & flag_mask).astype(bool)
 
         return ds
 

{obsarray-1.0.2 → obsarray-1.0.3}/obsarray/test/test_unc_accessor.py

@@ -34,7 +34,7 @@ def compare_err_corr_form(self, form, exp_form):
     self.assertCountEqual(form._unc_var_name, exp_form._unc_var_name)
 
 
-def create_ds():
+def create_ds(var_suffix="", dim_suffix="", coord_dim_suffix_extra=""):
     np.random.seed(0)
     temperature = 15 + 8 * np.random.randn(2, 2, 3)
     u_r_temperature = temperature * 0.02
@@ -47,42 +47,59 @@ def create_ds():
     reference_time = pd.Timestamp("2014-09-05")
 
     ds = xr.Dataset(
-        data_vars=dict(
-            temperature=(["x", "y", "time"], temperature, {"units": "K"}),
-        ),
-        coords=dict(
-            lon=(["x", "y"], lon),
-            lat=(["x", "y"], lat),
-            time=time,
-            reference_time=reference_time,
-        ),
+        data_vars={
+            "temperature"
+            + var_suffix: (
+                [
+                    "x" + dim_suffix,
+                    "y" + dim_suffix,
+                    "time" + dim_suffix + coord_dim_suffix_extra,
+                ],
+                temperature,
+                {"units": "K"},
+            ),
+        },
+        coords={
+            "lon" + var_suffix: (["x" + dim_suffix, "y" + dim_suffix], lon),
+            "lat" + var_suffix: (["x" + dim_suffix, "y" + dim_suffix], lat),
+            "time" + var_suffix: ("time" + dim_suffix + coord_dim_suffix_extra, time),
+            "reference_time": reference_time,
+        },
         attrs=dict(description="Weather related data."),
     )
 
-    ds.unc["temperature"]["u_ran_temperature"] = (
-        ["x", "y", "time"],
+    ds.unc["temperature" + var_suffix]["u_ran_temperature" + var_suffix] = (
+        [
+            "x" + dim_suffix,
+            "y" + dim_suffix,
+            "time" + dim_suffix + coord_dim_suffix_extra,
+        ],
         temperature * 0.05,
         {"units": "K", "pdf_shape": "gaussian"},
     )
 
-    ds.unc["temperature"]["u_sys_temperature"] = (
-        ["x", "y", "time"],
+    ds.unc["temperature" + var_suffix]["u_sys_temperature" + var_suffix] = (
+        [
+            "x" + dim_suffix,
+            "y" + dim_suffix,
+            "time" + dim_suffix + coord_dim_suffix_extra,
+        ],
         temperature * 0.03,
         {
             "units": "K",
             "err_corr": [
                 {
-                    "dim": "x",
+                    "dim": "x" + dim_suffix,
                     "form": "systematic",
                     "params": [],
                 },
                 {
-                    "dim": "y",
+                    "dim": "y" + dim_suffix,
                     "form": "systematic",
                     "params": [],
                 },
                 {
-                    "dim": "time",
+                    "dim": "time" + dim_suffix + coord_dim_suffix_extra,
                     "form": "systematic",
                     "params": [],
                 },
@@ -91,19 +108,26 @@ def create_ds():
         },
     )
 
-    ds.unc["temperature"]["u_str_temperature"] = (
-        ["x", "y", "time"],
+    ds.unc["temperature" + var_suffix]["u_str_temperature" + var_suffix] = (
+        [
+            "x" + dim_suffix,
+            "y" + dim_suffix,
+            "time" + dim_suffix + coord_dim_suffix_extra,
+        ],
         temperature * 0.1,
         {
             "units": "K",
             "err_corr": [
                 {
-                    "dim": ["x", "time"],
+                    "dim": [
+                        "x" + dim_suffix,
+                        "time" + dim_suffix + coord_dim_suffix_extra,
+                    ],
                     "form": "err_corr_matrix",
-                    "params": ["err_corr_str_temperature"],
+                    "params": ["err_corr_str_temperature" + var_suffix],
                 },
                 {
-                    "dim": "y",
+                    "dim": "y" + dim_suffix,
                     "form": "systematic",
                     "params": [],
                 },
@@ -112,8 +136,8 @@ def create_ds():
         },
     )
 
-    ds["err_corr_str_temperature"] = (
-        ["x.time", "x.time"],
+    ds["err_corr_str_temperature" + var_suffix] = (
+        ["x.time" + dim_suffix, "x.time" + dim_suffix],
         np.ones(
             (
                 temperature.shape[0] * temperature.shape[2],
@@ -740,6 +764,44 @@ class TestUncertainty(unittest.TestCase):
         exp_ecm = xr.DataArray(np.ones((12, 12)), dims=["x.y.time", "x.y.time"])
         xr.testing.assert_equal(ecm, exp_ecm)
 
+    def test_rename_vars(self):
+        var_suffix = "_test"
+        input_ds = create_ds()
+
+        ds = input_ds.unc.rename(
+            {
+                "temperature": "temperature" + var_suffix,
+                "lon": "lon" + var_suffix,
+                "lat": "lat" + var_suffix,
+                "time": "time" + var_suffix,
+                "u_ran_temperature": "u_ran_temperature" + var_suffix,
+                "u_str_temperature": "u_str_temperature" + var_suffix,
+                "u_sys_temperature": "u_sys_temperature" + var_suffix,
+                "err_corr_str_temperature": "err_corr_str_temperature" + var_suffix,
+            }
+        )
+
+        exp_ds = create_ds(var_suffix=var_suffix, coord_dim_suffix_extra=var_suffix)
+
+        xr.testing.assert_identical(ds, exp_ds)
+
+    def test_rename_dims(self):
+        dim_suffix = "_test"
+        input_ds = create_ds()
+
+        ds = input_ds.unc.rename_dims(
+            {
+                "x": "x" + dim_suffix,
+                "y": "y" + dim_suffix,
+                "time": "time" + dim_suffix,
+                "x.time": "x.time_test",
+            }
+        )
+
+        exp_ds = create_ds(dim_suffix=dim_suffix)
+
+        xr.testing.assert_identical(ds, exp_ds)
+
 
 if __name__ == "__main__":
     unittest.main()

obsarray-1.0.3/obsarray/test/test_utils.py

@@ -0,0 +1,169 @@
+"""test_utils - tests for obsarray.utils"""
+
+import unittest
+import numpy as np
+from obsarray import append_names, create_ds
+import xarray as xr
+
+__author__ = "Sam Hunt <sam.hunt@npl.co.uk>"
+__all__ = []
+
+
+def create_test_ds(suffix):
+    # define ds variables
+    template = {
+        "temperature"
+        + suffix: {
+            "dtype": np.float32,
+            "dim": ["x" + suffix, "y" + suffix, "time" + suffix],
+            "attributes": {
+                "units": "K",
+                "unc_comps": [
+                    "u_ran_temperature" + suffix,
+                    "u_sys_temperature" + suffix,
+                ],
+            },
+        },
+        "u_ran_temperature"
+        + suffix: {
+            "dtype": np.float32,
+            "dim": ["x" + suffix, "y" + suffix, "time" + suffix],
+            "attributes": {
+                "units": "K",
+                "err_corr": [
+                    {"dim": "x" + suffix, "form": "random", "params": [], "units": []},
+                    {"dim": "y" + suffix, "form": "random", "params": [], "units": []},
+                    {
+                        "dim": "time" + suffix,
+                        "form": "random",
+                        "params": [],
+                        "units": [],
+                    },
+                ],
+            },
+        },
+        "u_sys_temperature"
+        + suffix: {
+            "dtype": np.float32,
+            "dim": ["x" + suffix, "y" + suffix, "time" + suffix],
+            "attributes": {
+                "units": "K",
+                "err_corr": [
+                    {
+                        "dim": "x" + suffix,
+                        "form": "systematic",
+                        "params": [],
+                        "units": [],
+                    },
+                    {
+                        "dim": "y" + suffix,
+                        "form": "systematic",
+                        "params": [],
+                        "units": [],
+                    },
+                    {
+                        "dim": "time" + suffix,
+                        "form": "systematic",
+                        "params": [],
+                        "units": [],
+                    },
+                ],
+            },
+        },
+        "pressure"
+        + suffix: {
+            "dtype": np.float32,
+            "dim": ["x" + suffix, "y" + suffix, "time" + suffix],
+            "attributes": {"units": "Pa", "unc_comps": ["u_str_pressure" + suffix]},
+        },
+        "u_str_pressure"
+        + suffix: {
+            "dtype": np.float32,
+            "dim": ["x" + suffix, "y" + suffix, "time" + suffix],
+            "attributes": {
+                "units": "Pa",
+                "err_corr": [
+                    {"dim": "x" + suffix, "form": "random", "params": [], "units": []},
+                    {
+                        "dim": "y" + suffix,
+                        "form": "err_corr_matrix",
+                        "params": "err_corr_str_pressure_y",
+                        "units": [],
+                    },
+                    {
+                        "dim": "time" + suffix,
+                        "form": "systematic",
+                        "params": [],
+                        "units": [],
+                    },
+                ],
+            },
+        },
+        "err_corr_str_pressure_y"
+        + suffix: {
+            "dtype": np.float32,
+            "dim": ["y" + suffix, "y" + suffix],
+            "attributes": {"units": ""},
+        },
+        "n_moles"
+        + suffix: {
+            "dtype": np.float32,
+            "dim": ["x" + suffix, "y" + suffix, "time" + suffix],
+            "attributes": {"units": "", "unc_comps": ["u_ran_n_moles" + suffix]},
+        },
+        "u_ran_n_moles"
+        + suffix: {
+            "dtype": np.float32,
+            "dim": ["x" + suffix, "y" + suffix, "time" + suffix],
+            "attributes": {
+                "units": "",
+                "err_corr": [
+                    {"dim": "x" + suffix, "form": "random", "params": [], "units": []},
+                    {"dim": "y" + suffix, "form": "random", "params": [], "units": []},
+                    {
+                        "dim": "time" + suffix,
+                        "form": "random",
+                        "params": [],
+                        "units": [],
+                    },
+                ],
+            },
+        },
+    }
+
+    # define dim_size_dict to specify size of arrays
+    dim_sizes = {"x" + suffix: 20, "y" + suffix: 30, "time" + suffix: 6}
+
+    # create dataset template
+    ds = create_ds(template, dim_sizes)
+
+    # populate with example data
+    ds["temperature" + suffix].values = 293 * np.ones((20, 30, 6))
+    ds["u_ran_temperature" + suffix].values = 1 * np.ones((20, 30, 6))
+    ds["u_sys_temperature" + suffix].values = 0.4 * np.ones((20, 30, 6))
+    ds["pressure" + suffix].values = 10**5 * np.ones((20, 30, 6))
+    ds["u_str_pressure" + suffix].values = 10 * np.ones((20, 30, 6))
+    ds["err_corr_str_pressure_y" + suffix].values = 0.5 * np.ones(
+        (30, 30)
+    ) + 0.5 * np.eye(30)
+    ds["n_moles" + suffix].values = 40 * np.ones((20, 30, 6))
+    ds["u_ran_n_moles" + suffix].values = 1 * np.ones((20, 30, 6))
+
+    ds.attrs["attr" + suffix] = "val"
+
+    return ds
+
+
+class TestAppendNames(unittest.TestCase):
+    def test_append_names(self):
+
+        input_ds = create_test_ds(suffix="")
+        ds = append_names(input_ds, "_test")
+
+        exp_ds = create_test_ds(suffix="_test")
+
+        xr.testing.assert_identical(ds, exp_ds)
+
+
+if __name__ == "__main__":
+    unittest.main()

{obsarray-1.0.2 → obsarray-1.0.3}/obsarray/unc_accessor.py

@@ -9,6 +9,7 @@ from obsarray.templater.template_util import create_var
 from obsarray.templater.dataset_util import DatasetUtil
 from obsarray.err_corr import err_corr_forms, BaseErrCorrForm
 from obsarray.utils import empty_err_corr_matrix
+from xarray.core.types import T_Dataset
 
 
 __author__ = "Sam Hunt <sam.hunt@npl.co.uk>"
@@ -308,12 +309,24 @@ class Uncertainty:
                 ]
             ):
                 if dim_err_corr[1].form in ["random", "systematic"]:
-                    err_corr_dict[dim_err_corr[0]] = dim_err_corr[1].form
+                    if isinstance(dim_err_corr[0], List):
+                        for dim in dim_err_corr[0]:
+                            err_corr_dict[dim] = dim_err_corr[1].form
+
+                    else:
+                        err_corr_dict[dim_err_corr[0]] = dim_err_corr[1].form
 
                 elif dim_err_corr[1].form == "err_corr_matrix":
-                    err_corr_dict[dim_err_corr[0]] = self._obj[
-                        dim_err_corr[1].params[0]
-                    ].values
+                    if isinstance(dim_err_corr[0], List):
+                        for dim in dim_err_corr[0]:
+                            err_corr_dict[dim] = self._obj[
+                                dim_err_corr[1].params[0]
+                            ].values
+
+                    else:
+                        err_corr_dict[dim_err_corr[0]] = self._obj[
+                            dim_err_corr[1].params[0]
+                        ].values
 
                 else:
                     raise NotImplementedError(
@@ -894,6 +907,88 @@ class UncAccessor(object):
         del self._obj[unc_var]
         self._obj[obs_var].attrs["unc_comps"].remove(unc_var)
 
+    def rename(self, vars_dict: dict[str, str]) -> T_Dataset:
+        """
+        Returns a new dataset with renamed variables - safely handling `unc_vars` and related metadata
+
+        :param vars_dict: Dictionary whose keys are current variable names and whose values are the desired names. The desired names must not be the name of an existing dimension or Variable in the Dataset.
+        :returns: Dataset with renamed variables
+        """
+
+        # handle case that xarray.Dataset.rename renames the dimension associated with a renamed coordinate dimension
+        coord_dim_dict = {
+            str(dim): vars_dict[dim]
+            for dim in self._obj.dims
+            if (dim in self._obj.coords) and (dim in vars_dict.keys())
+        }
+        ds = self.rename_dims(coord_dim_dict)
+
+        # update metadata where unc_var err corr param to be renamed
+        unc_var_paths = []
+        for obs_var in ds.unc.obs_vars:
+            for unc_var in ds.unc[obs_var]:
+                unc_var_paths.append((obs_var, unc_var._unc_var_name))
+
+        for unc_var_path in unc_var_paths:
+            unc_var_i = unc_var_path[1]
+
+            for attr in ds[unc_var_i].attrs.keys():
+                if (attr[:9] == "err_corr_") and (attr[-7:] == "_params"):
+                    for i, param in enumerate(ds[unc_var_i].attrs[attr]):
+                        if param in vars_dict.keys():
+                            ds[unc_var_i].attrs[attr][i] = vars_dict[param]
+
+        # safely update unc_vars
+        for unc_var_path in unc_var_paths:
+            obs_var_i = unc_var_path[0]
+            unc_var_i = unc_var_path[1]
+            if unc_var_i in vars_dict:
+                ds = ds.unc[obs_var_i][unc_var_i].rename(vars_dict[unc_var_i])
+
+        # update remaining variable names
+        non_unc_var_names = list(
+            filter(lambda x: x not in self.unc_vars.keys(), self._obj.variables.keys())
+        )
+        var_dict_no_unc = {
+            n: vars_dict[n] for n in non_unc_var_names if n in vars_dict.keys()
+        }
+        ds = ds.rename(var_dict_no_unc)
+
+        return ds
+
+    def rename_dims(self, dims_dict: dict[str, str]) -> T_Dataset:
+        """
+        Returns a new dataset with renamed dimensions - safely handling `unc_vars` related metadata
+
+        :param dims_dict: Dictionary whose keys are current dimension names and whose values are the desired names. The desired names must not be the name of an existing dimension or Variable in the Dataset.
+        :returns: Dataset with renamed dimensions
+        """
+
+        # update dimension names
+        obj = self._obj.rename_dims(dims_dict)
+
+        # update uncertainty metadata related to variable names
+        unc_var_names = []
+        for obs_var in obj.unc.obs_vars:
+            for unc_var in obj.unc[obs_var]:
+                unc_var_names.append(unc_var._unc_var_name)
+
+        for unc_var_name in unc_var_names:
+            for attr in obj[unc_var_name].attrs.keys():
+                if (attr[:9] == "err_corr_") and (attr[-4:] == "_dim"):
+                    if isinstance(obj[unc_var_name].attrs[attr], str):
+                        if obj[unc_var_name].attrs[attr] in dims_dict:
+                            obj[unc_var_name].attrs[attr] = dims_dict[
+                                obj[unc_var_name].attrs[attr]
+                            ]
+
+                    if isinstance(obj[unc_var_name].attrs[attr], list):
+                        for i, attr_i in enumerate(obj[unc_var_name].attrs[attr]):
+                            if attr_i in dims_dict:
+                                obj[unc_var_name].attrs[attr][i] = dims_dict[attr_i]
+
+        return obj
+
 
 if __name__ == "__main__":
     pass

obsarray-1.0.3/obsarray/utils.py

@@ -0,0 +1,66 @@
+"""utils - utilities for obsarray"""
+
+import numpy as np
+import xarray as xr
+from xarray.core.types import T_Dataset
+
+__author__ = "Sam Hunt <sam.hunt@npl.co.uk>"
+__all__ = ["empty_err_corr_matrix", "append_names"]
+
+
+def empty_err_corr_matrix(obs_var: xr.DataArray):
+    """
+    Returns diagonal error correlation matrix for observation variable
+
+    :param obs_var: uncertainty variable
+    :return: diagonal error correlation matrix
+    """
+
+    dim_names = [dim for dim in obs_var.dims]
+    dim_lens = [len(obs_var[dim]) for dim in dim_names]
+
+    n_elems = int(np.prod(dim_lens))
+    erc_dim_name = ".".join(dim_names)
+
+    err_corr_matrix = xr.DataArray(np.eye(n_elems), dims=[erc_dim_name, erc_dim_name])
+
+    return err_corr_matrix
+
+
+def append_names(
+    ds: T_Dataset,
+    suffix: str,
+    skip_vars: bool = False,
+    skip_dims: bool = False,
+    skip_attrs: bool = False,
+) -> T_Dataset:
+    """
+    Appends a suffix to the names of dataset variables, dimensions, and attributes - safely handling `unc_vars` and associated metadata
+
+    :param ds: xarray dataset
+    :param suffix: suffix to append to dataset variable, dimension, and attribute names
+    :param skip_vars: (default: `False`) switch to skip applying suffix to variable names
+    :param skip_dims: (default: `False`) switch to skip applying suffix to dimension names
+    :param skip_attrs: (default: `False`) switch to skip applying suffix to variable names
+    :returns: ds with suffix appended to names of variables, dimensions, attributes
+    """
+
+    # update variable names
+    if not skip_vars:
+        var_rename = {var_name: var_name + suffix for var_name in ds.variables.keys()}
+        ds = ds.unc.rename(var_rename)
+
+    # update dimension names
+    if not skip_dims:
+        dim_rename = {dim_name: dim_name + suffix for dim_name in ds.dims.keys()}
+        ds = ds.unc.rename_dims(dim_rename)
+
+    # update attribute names
+    if not skip_attrs:
+        ds.attrs = {key + suffix: value for key, value in ds.attrs.items()}
+
+    return ds
+
+
+if __name__ == "__main__":
+    pass

{obsarray-1.0.2 → obsarray-1.0.3/obsarray.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: obsarray
-Version: 1.0.2
+Version: 1.0.3
 Summary: Measurement data handling in Python
 Author-email: CoMet Toolkit Team <team@comet-toolkit.org>
 Project-URL: Homepage, https://github.com/comet-toolkit/obsarray

{obsarray-1.0.2 → obsarray-1.0.3}/obsarray.egg-info/SOURCES.txt

@@ -29,4 +29,5 @@ obsarray/templater/tests/test_template_util.py
 obsarray/test/__init__.py
 obsarray/test/test_err_corr_forms.py
 obsarray/test/test_flag_accessor.py
-obsarray/test/test_unc_accessor.py
+obsarray/test/test_unc_accessor.py
+obsarray/test/test_utils.py