obsarray 1.0.2__py3-none-any.whl → 1.1__py3-none-any.whl

obsarray/__init__.py

@@ -3,12 +3,18 @@
 __author__ = "Sam Hunt <sam.hunt@npl.co.uk>"
 __all__ = []
 
-from ._version import get_versions
+from importlib.metadata import PackageNotFoundError, version
+
 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
+from obsarray.utils import append_names
+from obsarray.options import set_options, get_options
+from obsarray.conventions import UNCConventionsWarning
 
-__version__ = get_versions()["version"]
-del get_versions
+try:
+    __version__ = version("obsarray")
+except PackageNotFoundError:
+    __version__ = "0.0.0+unknown"

obsarray/conventions.py

@@ -0,0 +1,84 @@
+"""conventions - handling of the UNC metadata conventions version obsarray follows"""
+
+import inspect
+import os
+import warnings
+
+from obsarray.options import OPTIONS
+
+__author__ = "Sam Hunt <sam.hunt@npl.co.uk>"
+__all__ = ["UNCConventionsWarning"]
+
+
+UNC_CONVENTIONS_DOCS_URL = (
+    "https://obsarray.readthedocs.io/en/latest/content/user/unc_conventions.html"
+)
+
+_UNC_CONVENTIONS_MESSAGE = (
+    "obsarray currently writes uncertainty metadata following v0.1 of the UNC "
+    "specification. A future release will default to UNC draft v0.2, which is proposed "
+    "for inclusion into the CF conventions and is not backwards compatible with v0.1 (for "
+    "example, 'unc_comps' becomes 'uncertainty_variables' and 'err_corr_*' becomes "
+    "'error_correlation'). See " + UNC_CONVENTIONS_DOCS_URL + " for details. To keep "
+    "the current behaviour and silence this warning, call "
+    'obsarray.set_options(unc_conventions="v0.1").'
+)
+
+# set once the warning has been issued, so it is only shown once per session
+_warned = False
+
+
+class UNCConventionsWarning(FutureWarning):
+    """
+    Warning that obsarray's default UNC conventions version will change from v0.1 to draft v0.2
+
+    Issued once per session, the first time obsarray writes uncertainty metadata, unless a conventions
+    version has been chosen explicitly with :py:class:`~obsarray.options.set_options`. It can also be
+    filtered like any other warning:
+
+    .. code-block:: python
+
+        import warnings
+        import obsarray
+
+        warnings.filterwarnings("ignore", category=obsarray.UNCConventionsWarning)
+    """
+
+
+def warn_unc_conventions() -> None:
+    """
+    Warns, once per session, that the default UNC conventions version will change - unless a version has
+    been chosen explicitly with :py:class:`~obsarray.options.set_options`
+    """
+
+    global _warned
+
+    if _warned or OPTIONS["unc_conventions"] is not None:
+        return
+
+    _warned = True
+    warnings.warn(
+        _UNC_CONVENTIONS_MESSAGE, UNCConventionsWarning, stacklevel=_find_stack_level()
+    )
+
+
+def _find_stack_level() -> int:
+    """
+    Returns the ``stacklevel`` of the first frame outside obsarray, so warnings point at the calling code
+
+    :return: stack level to pass to :py:func:`warnings.warn` from the function calling this one
+    """
+
+    pkg_dir = os.path.dirname(os.path.abspath(__file__)) + os.sep
+
+    frame = inspect.currentframe()
+    level = 0
+    while frame is not None and frame.f_code.co_filename.startswith(pkg_dir):
+        frame = frame.f_back
+        level += 1
+
+    return level
+
+
+if __name__ == "__main__":
+    pass

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, List
+from typing import Callable, Type
 import numpy as np
 from comet_maths.linear_algebra.matrix_conversion import expand_errcorr_dims
 
@@ -150,7 +150,7 @@ class BaseErrCorrForm(abc.ABC):
         )
 
     @abc.abstractmethod
-    def build_matrix(self, sli: Union[np.ndarray, tuple]) -> np.ndarray:
+    def build_matrix(self, sli: tuple) -> np.ndarray:
         """
         Returns uncertainty effect error-correlation matrix, populated with error-correlation values defined
         in this parameterisation
@@ -161,7 +161,7 @@ class BaseErrCorrForm(abc.ABC):
         """
         pass
 
-    def build_dot_matrix(self, sli: Union[np.ndarray, tuple]) -> np.ndarray:
+    def build_dot_matrix(self, sli: tuple) -> np.ndarray:
         """
         Returns expanded error correlation matrix for use in dot product with error correlation
         in other dimensions.
@@ -201,7 +201,6 @@ def register_err_corr_form(form_name: str) -> Callable:
 
 @register_err_corr_form("random")
 class RandomCorrelation(BaseErrCorrForm):
-
     form = "random"
     is_random = True
 
@@ -226,7 +225,6 @@ class RandomCorrelation(BaseErrCorrForm):
 
 @register_err_corr_form("systematic")
 class SystematicCorrelation(BaseErrCorrForm):
-
     form = "systematic"
     is_systematic = True
 
@@ -251,7 +249,6 @@ class SystematicCorrelation(BaseErrCorrForm):
 
 @register_err_corr_form("err_corr_matrix")
 class ErrCorrMatrixCorrelation(BaseErrCorrForm):
-
     form = "err_corr_matrix"
 
     def build_matrix(self, sli: tuple) -> np.ndarray:
@@ -278,7 +275,6 @@ class ErrCorrMatrixCorrelation(BaseErrCorrForm):
 
 @register_err_corr_form("ensemble")
 class EnsembleCorrelation(BaseErrCorrForm):
-
     form = "ensemble"
 
     def build_matrix(self, sli: tuple) -> np.ndarray:

obsarray/flag_accessor.py

@@ -2,7 +2,7 @@
 
 import numpy as np
 import xarray as xr
-from typing import List, Optional, Union, Tuple
+from typing import Hashable, List, Optional, Union, Tuple
 from obsarray.templater.template_util import create_var
 from obsarray.templater.dataset_util import DatasetUtil
 
@@ -45,7 +45,7 @@ class Flag:
         """Custom  __repr__"""
         return str(self)
 
-    def __getitem__(self, sli: tuple):
+    def __getitem__(self, sli: Union[tuple, slice, int]):
         """
         Defines variable slice
 
@@ -58,7 +58,7 @@ class Flag:
 
         return self
 
-    def __setitem__(self, sli: tuple, flag_value):
+    def __setitem__(self, sli: Union[tuple, slice, int], flag_value):
         """
         Sets flag values
 
@@ -83,26 +83,28 @@ class Flag:
                 )
             else:
                 self._obj[self._flag_var_name].values[self._sli] = (
-                    self._obj[self._flag_var_name][self._sli].values & ~flag_mask
-                )
+                    self._obj[self._flag_var_name][self._sli].values
+                    & np.array(~flag_mask)
+                ).astype(self._obj[self._flag_var_name].values[self._sli].dtype)
 
         # else apply mask
         else:
             if flag_value.dtype is not np.dtype(bool):
                 TypeError("Flag mask must of boolean type")
 
-            i_true = np.where(flag_value == True)
-            i_false = np.where(flag_value == False)
+            i_true = np.where(flag_value == True)  # noqa: E712 (elementwise)
+            i_false = np.where(flag_value == False)  # noqa: E712 (elementwise)
 
             self._obj[self._flag_var_name][self._sli].values[i_true] = np.array(
                 self._obj[self._flag_var_name][self._sli].values[i_true] | flag_mask
             )
 
             self._obj[self._flag_var_name][self._sli].values[i_false] = np.array(
-                self._obj[self._flag_var_name][self._sli].values[i_false] & ~flag_mask
-            )
+                self._obj[self._flag_var_name][self._sli].values[i_false]
+                & np.array(~flag_mask)
+            ).astype(self._obj[self._flag_var_name].values[self._sli].dtype)
 
-    def _expand_sli(self, sli: Optional[tuple] = None) -> tuple:
+    def _expand_sli(self, sli: Optional[Union[tuple, slice, int]] = None) -> tuple:
         """
         Function to expand the provided sli so that it always has the right number of dimensions
 
@@ -118,12 +120,14 @@ class Flag:
         # E.g. if providing [0] for a variable with 3 dimensions, this becomes
         # [0,slice(None),slice(None)]
         else:
-            out_sli = list([slice(None)] * self._obj[self._flag_var_name].ndim)
+            out_sli_list: list = list(
+                [slice(None)] * self._obj[self._flag_var_name].ndim
+            )
             sli_list = list(sli) if isinstance(sli, tuple) else [sli]
             for i in range(len(sli_list)):
                 if not sli_list[i] == ":":
-                    out_sli[i] = sli_list[i]
-            out_sli = tuple(out_sli)
+                    out_sli_list[i] = sli_list[i]
+            out_sli = tuple(out_sli_list)
 
         return out_sli
 
@@ -194,12 +198,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
@@ -318,8 +322,7 @@ class FlagAccessor(object):
         """
 
         # add uncertainty variable
-        if type(flag_def) == xr.DataArray:
-
+        if type(flag_def) is xr.DataArray:
             # add necessary flag metadata if missing from provided data array
             flag_meanings, flag_masks = DatasetUtil.unpack_flag_attrs(flag_def.attrs)
             flag_def.attrs.update(DatasetUtil.pack_flag_attrs(flag_meanings))
@@ -327,8 +330,7 @@ class FlagAccessor(object):
             self._obj[flag_var_name] = flag_def
 
         # use templater functionality if var defined with tuple
-        elif type(flag_def) == tuple:
-
+        elif type(flag_def) is tuple:
             attrs = flag_def[1]
 
             if "flag_meanings" not in attrs:
@@ -415,7 +417,7 @@ class FlagAccessor(object):
 
         return self._obj[list(flag_var_names)].data_vars
 
-    def _is_data_var(self, var_name: str) -> bool:
+    def _is_data_var(self, var_name: Hashable) -> bool:
         """
         Returns true if named dataset variable is an data variable (i.e. not a flag variable)
 
@@ -426,7 +428,7 @@ class FlagAccessor(object):
             return True
         return False
 
-    def _is_flag_var(self, var_name: str) -> bool:
+    def _is_flag_var(self, var_name: Hashable) -> bool:
         """
         Returns true if named dataset variable is an flag variable
 

obsarray/options.py

@@ -0,0 +1,78 @@
+"""options - global obsarray options"""
+
+from typing import Any, Dict
+
+__author__ = "Sam Hunt <sam.hunt@npl.co.uk>"
+__all__ = ["set_options", "get_options"]
+
+
+# None means "not chosen explicitly" - obsarray then uses its default behaviour
+OPTIONS: Dict[str, Any] = {"unc_conventions": None}
+
+_VALID_VALUES = {"unc_conventions": ("v0.1",)}
+
+
+class set_options:
+    """
+    Sets obsarray global options, either for the rest of the session or within a ``with`` block
+
+    Available options:
+
+    * ``unc_conventions`` - version of the `UNC specification
+      <https://comet-toolkit.github.io/unc_website/>`_ obsarray follows when writing uncertainty metadata.
+      Currently the only supported value is ``"v0.1"`` (obsarray's current behaviour). Setting it explicitly
+      also silences the :py:class:`~obsarray.conventions.UNCConventionsWarning` about the upcoming change of
+      default to draft v0.2.
+
+    .. code-block:: python
+
+        import obsarray
+
+        # for the rest of the session
+        obsarray.set_options(unc_conventions="v0.1")
+
+        # or only within a block
+        with obsarray.set_options(unc_conventions="v0.1"):
+            ds.unc["temperature"]["u_noise"] = (["x"], u_noise, {"units": "K"})
+
+    :param kwargs: option names and their new values
+    """
+
+    def __init__(self, **kwargs: Any):
+        self._old: Dict[str, Any] = {}
+
+        for name, value in kwargs.items():
+            if name not in OPTIONS:
+                raise ValueError(
+                    f"{name!r} is not an obsarray option, must be one of {sorted(OPTIONS)}"
+                )
+
+            if value not in _VALID_VALUES[name]:
+                raise ValueError(
+                    f"{value!r} is not a valid value for {name!r}, must be one of "
+                    f"{list(_VALID_VALUES[name])}"
+                )
+
+            self._old[name] = OPTIONS[name]
+
+        OPTIONS.update(kwargs)
+
+    def __enter__(self) -> None:
+        return None
+
+    def __exit__(self, *exc_info: Any) -> None:
+        OPTIONS.update(self._old)
+
+
+def get_options() -> Dict[str, Any]:
+    """
+    Returns a copy of the current obsarray global options
+
+    :return: option names and their values (``None`` if not set explicitly)
+    """
+
+    return dict(OPTIONS)
+
+
+if __name__ == "__main__":
+    pass

obsarray/templater/dataset_util.py

@@ -6,7 +6,9 @@ import string
 from copy import deepcopy
 import xarray
 import numpy
+from numpy.typing import DTypeLike
 from typing import Union, Optional, List, Dict, Tuple
+from obsarray.conventions import warn_unc_conventions
 
 
 __author__ = "Sam Hunt <sam.hunt@npl.co.uk>"
@@ -34,9 +36,9 @@ class DatasetUtil:
     @staticmethod
     def create_default_array(
         dim_sizes: List[int],
-        dtype: numpy.typecodes,
+        dtype: DTypeLike,
         dim_names: Optional[List[str]] = None,
-        fill_value: Optional[Union[int, float]] = None,
+        fill_value: Optional[Union[int, float, numpy.number]] = None,
     ) -> xarray.DataArray:
         """
         Return default empty xarray DataArray
@@ -66,10 +68,10 @@ class DatasetUtil:
     @staticmethod
     def create_variable(
         dim_sizes: List[int],
-        dtype: numpy.typecodes,
+        dtype: DTypeLike,
         dim_names: Optional[List[str]] = None,
-        attributes: Dict = None,
-        fill_value: Optional[Union[int, float]] = None,
+        attributes: Optional[Dict] = None,
+        fill_value: Optional[Union[int, float, numpy.number]] = None,
     ) -> xarray.Variable:
         """
         Return default empty xarray Variable
@@ -107,7 +109,7 @@ class DatasetUtil:
     @staticmethod
     def create_unc_variable(
         dim_sizes: List[int],
-        dtype: numpy.typecodes,
+        dtype: DTypeLike,
         dim_names: List[str],
         attributes: Optional[Dict] = None,
         pdf_shape: str = "gaussian",
@@ -145,6 +147,8 @@ class DatasetUtil:
             populated to the effect of this assumption.
         """
 
+        warn_unc_conventions()
+
         # define uncertainty variable attributes, based on FIDUCEO Full FCDR definition (if required)
         attributes = {} if attributes is None else attributes
 
@@ -315,7 +319,7 @@ class DatasetUtil:
 
     @staticmethod
     def add_flag_meaning_to_attrs(
-        attrs: dict, flag_meaning: str, dtype: numpy.typecodes
+        attrs: dict, flag_meaning: str, dtype: DTypeLike
     ) -> dict:
         """
         Add new meaning to flag variable attributes
@@ -384,7 +388,7 @@ class DatasetUtil:
         return updated_attrs
 
     @staticmethod
-    def return_flags_dtype(n_masks: int) -> numpy.typecodes:
+    def return_flags_dtype(n_masks: int) -> DTypeLike:
         """
         Return required flags array data type
 
@@ -404,10 +408,10 @@ class DatasetUtil:
     @staticmethod
     def add_encoding(
         variable: xarray.Variable,
-        dtype: numpy.typecodes,
+        dtype: DTypeLike,
         scale_factor: Optional[float] = 1.0,
         offset: Optional[float] = 0.0,
-        fill_value: Optional[Union[int, float]] = None,
+        fill_value: Optional[Union[int, float, numpy.number]] = None,
         chunksizes: Optional[float] = None,
     ):
         """
@@ -442,7 +446,9 @@ class DatasetUtil:
         variable.encoding = encoding_dict
 
     @staticmethod
-    def get_default_fill_value(dtype: numpy.typecodes) -> Union[int, float]:
+    def get_default_fill_value(
+        dtype: DTypeLike,
+    ) -> Optional[Union[int, float, numpy.number]]:
         """
         Returns default fill_value for given data type
 
@@ -469,6 +475,7 @@ class DatasetUtil:
             return numpy.float32(9.96921e36)
         elif dtype == numpy.float64:
             return numpy.float64(9.969209968386869e36)
+        return None
 
     @staticmethod
     def _get_flag_encoding(da):
@@ -507,7 +514,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
 
@@ -569,7 +576,7 @@ class DatasetUtil:
 
         set_flags = DatasetUtil.unpack_flags(da)[flag_name]
 
-        if numpy.any(set_flags == True) and error_if_set:
+        if numpy.any(set_flags == True) and error_if_set:  # noqa: E712
             raise ValueError(
                 "Flag " + flag_name + " already set for variable " + da.name
             )
@@ -597,7 +604,7 @@ class DatasetUtil:
 
         set_flags = DatasetUtil.unpack_flags(da)[flag_name]
 
-        if numpy.any(set_flags == False) and error_if_unset:
+        if numpy.any(set_flags == False) and error_if_unset:  # noqa: E712
             raise ValueError(
                 "Flag " + flag_name + " already set for variable " + da.name
             )

obsarray/templater/dstemplater.py

@@ -122,7 +122,7 @@ class DSTemplater:
         :return: empty sizes dictionary
         """
 
-        dim_sizes_dict = dict()
+        dim_sizes_dict: Dict[str, None] = dict()
         for dim in self.return_template_dim_names(ds_format):
             dim_sizes_dict[dim] = None
 

obsarray/templater/template_util.py

@@ -91,7 +91,6 @@ class TemplateUtil:
         """
 
         for var_name in template.keys():
-
             var = TemplateUtil._create_var(var_name, template[var_name], size)
 
             ds[var_name] = var
@@ -131,6 +130,10 @@ class TemplateUtil:
         # Create variable and add to dataset
         if isinstance(dtype, str):
             if dtype == "flag":
+                if attributes is None:
+                    raise ValueError(
+                        "Flag variable " + var_name + " must define flag_meanings"
+                    )
                 flag_meanings = attributes.pop("flag_meanings")
                 variable = du.create_flags_variable(
                     dim_sizes,
@@ -173,7 +176,7 @@ class TemplateUtil:
         """
 
         # Variable name must be type str
-        if type(variable_name) != str:
+        if type(variable_name) is not str:
             raise TypeError(
                 "Invalid variable name: " + str(variable_name) + " (must be string)"
             )

obsarray/templater/tests/test_dataset_util.py

@@ -471,7 +471,9 @@ class TestDatasetUtil(unittest.TestCase):
 
         self.assertEqual(-127, DatasetUtil.get_default_fill_value(np.int8))
         self.assertEqual(-32767, DatasetUtil.get_default_fill_value(np.int16))
-        self.assertEqual(np.uint16(-1), DatasetUtil.get_default_fill_value(np.uint16))
+        self.assertEqual(
+            np.array(-1).astype("uint16"), DatasetUtil.get_default_fill_value(np.uint16)
+        )
         self.assertEqual(-2147483647, DatasetUtil.get_default_fill_value(np.int32))
         self.assertEqual(
             -9223372036854775806, DatasetUtil.get_default_fill_value(np.int64)

obsarray/test/test_conventions.py

@@ -0,0 +1,127 @@
+"""test_conventions - tests for obsarray.conventions"""
+
+import unittest
+import warnings
+import numpy as np
+import xarray as xr
+from obsarray import UNCConventionsWarning, create_ds, get_options, set_options
+from obsarray import conventions
+from obsarray.options import OPTIONS
+
+__author__ = "Sam Hunt <sam.hunt@npl.co.uk>"
+__all__ = []
+
+
+def create_obs_ds():
+    return xr.Dataset({"temperature": (["x"], np.ones(3), {"units": "K"})})
+
+
+class TestUNCConventionsWarning(unittest.TestCase):
+    def setUp(self):
+        # each test starts as a fresh session that hasn't warned yet
+        self.original_warned = conventions._warned
+        self.original_options = get_options()
+        conventions._warned = False
+
+        self.ds = create_obs_ds()
+
+    def tearDown(self):
+        conventions._warned = self.original_warned
+        OPTIONS.update(self.original_options)
+
+    def add_unc_var(self, unc_var="u_noise"):
+        self.ds.unc["temperature"][unc_var] = (["x"], np.ones(3) * 0.1, {"units": "K"})
+
+    def assertNoUNCConventionsWarning(self, func, *args, **kwargs):
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            func(*args, **kwargs)
+
+        self.assertFalse(
+            [w for w in caught if issubclass(w.category, UNCConventionsWarning)]
+        )
+
+    def test_is_future_warning(self):
+        # FutureWarning is shown to end users by default, unlike DeprecationWarning
+        self.assertTrue(issubclass(UNCConventionsWarning, FutureWarning))
+
+    def test_warns_on_adding_unc_var(self):
+        with self.assertWarns(UNCConventionsWarning):
+            self.add_unc_var()
+
+    def test_warns_on_adding_unc_var_dataarray(self):
+        unc = xr.DataArray(np.ones(3) * 0.1, dims=["x"], attrs={"units": "K"})
+
+        with self.assertWarns(UNCConventionsWarning):
+            self.ds.unc["temperature"]["u_noise"] = unc
+
+    def test_warns_on_template_unc_var(self):
+        template = {
+            "temperature": {
+                "dim": ["x"],
+                "dtype": np.float32,
+                "attributes": {"units": "K", "unc_comps": ["u_temperature"]},
+            },
+            "u_temperature": {
+                "dim": ["x"],
+                "dtype": np.float32,
+                "attributes": {
+                    "units": "K",
+                    "err_corr": [{"dim": "x", "form": "random", "params": []}],
+                },
+            },
+        }
+
+        with self.assertWarns(UNCConventionsWarning):
+            create_ds(template, {"x": 3})
+
+    def test_warns_once_per_session(self):
+        with self.assertWarns(UNCConventionsWarning):
+            self.add_unc_var("u_noise")
+
+        self.assertNoUNCConventionsWarning(self.add_unc_var, "u_calibration")
+
+    def test_no_warning_when_conventions_set(self):
+        set_options(unc_conventions="v0.1")
+
+        self.assertNoUNCConventionsWarning(self.add_unc_var)
+
+    def test_no_warning_within_set_options_block(self):
+        with set_options(unc_conventions="v0.1"):
+            self.assertNoUNCConventionsWarning(self.add_unc_var, "u_noise")
+
+        # not silenced for good - the next write outside the block still warns
+        with self.assertWarns(UNCConventionsWarning):
+            self.add_unc_var("u_calibration")
+
+    def test_no_warning_on_read(self):
+        with set_options(unc_conventions="v0.1"):
+            self.add_unc_var()
+
+        self.assertNoUNCConventionsWarning(
+            lambda: self.ds.unc["temperature"]["u_noise"].value
+        )
+
+    def test_warning_points_at_calling_code(self):
+        user_code = compile(
+            'ds.unc["temperature"]["u_noise"] = (["x"], u, {"units": "K"})',
+            "user_script.py",
+            "exec",
+        )
+
+        with self.assertWarns(UNCConventionsWarning) as cm:
+            exec(user_code, {"ds": self.ds, "u": np.ones(3) * 0.1})
+
+        self.assertEqual(cm.filename, "user_script.py")
+
+    def test_message_explains_how_to_silence(self):
+        with self.assertWarns(UNCConventionsWarning) as cm:
+            self.add_unc_var()
+
+        message = str(cm.warning)
+        self.assertIn('set_options(unc_conventions="v0.1")', message)
+        self.assertIn(conventions.UNC_CONVENTIONS_DOCS_URL, message)
+
+
+if __name__ == "__main__":
+    unittest.main()