obsarray 0.2.6__tar.gz → 1.0__tar.gz

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

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

{obsarray-0.2.6 → obsarray-1.0}/docs/conf.py

@@ -112,7 +112,7 @@ html_theme = "sphinx_book_theme"
 #
 # html_theme_options = {}
 
-html_logo = "figs/comet_logo.png"
+html_logo = "figs/obsarray.png"
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,

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

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-03-26T17:59:27+0000",
+ "date": "2024-04-02T15:14:15+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "3f90a44048e43a24a7ec1115d7b727944416ba9f",
- "version": "v0.2.6"
+ "full-revisionid": "22fe504c5299f2e3adbb924ab737227182325cf6",
+ "version": "v1.0"
 }
 '''  # END VERSION_JSON
 

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

@@ -69,22 +69,23 @@ class BaseErrCorrForm(abc.ABC):
         """Form name"""
         pass
 
-    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=submatrix_dim,
-            out_dim=list(self._obj[self._unc_var_name][sli].dims),
-            dim_sizes=self.get_sliced_dim_sizes_uncvar(sli),
-        )
+    def get_varshape_errcorr(self):
+        """
+        return shape of uncertainty variable, including only dimensions which are included in the current error correlation form.
+
+        :return: shape of included dimensions
+        """
+        all_dims = self._obj[self._unc_var_name].dims
+        all_dims_sizes = self._obj.sizes
+
+        return tuple([all_dims_sizes[dim] for dim in all_dims if dim in self.dims])
 
     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
+        :return: dictionary with 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
@@ -98,7 +99,7 @@ class BaseErrCorrForm(abc.ABC):
         included in the current error correlation form.
 
         :param sli: slice (tuple with slice for each dimension)
-        :return: shape of included sliced dimensions
+        :return: dictionary with shape of included sliced dimensions
         """
         uncvar_sizes = self.get_sliced_dim_sizes_uncvar(sli)
         sliced_dims = self.get_sliced_dims_errcorr(sli)
@@ -131,17 +132,21 @@ class BaseErrCorrForm(abc.ABC):
 
         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_errcorr_matrix(self, err_corr_matrix, variable_shape, sli) -> np.ndarray:
+        """
+        Slice the provided error correlation matrix (typically the error correlation matrix of the
+        BaseErrCorrForm) using the
 
-    def slice_flattened_matrix(self, flattened_matrix, variable_shape, sli):
+        :param err_corr_matrix: error correlation matrix to be sliced
+        :param variable_shape: tuple with the length of the dimensions in the error correlation matrix (in correct order for flattening)
+        :param sli: slice of observation variable to return error-correlation matrix for
+        :return: sliced error correlation matrix
+        """
         mask_array = np.ones(variable_shape, dtype=bool)
         mask_array[sli] = False
 
         return np.delete(
-            np.delete(flattened_matrix, mask_array.ravel(), 0), mask_array.ravel(), 1
+            np.delete(err_corr_matrix, mask_array.ravel(), 0), mask_array.ravel(), 1
         )
 
     @abc.abstractmethod
@@ -158,16 +163,24 @@ class BaseErrCorrForm(abc.ABC):
 
     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
+        Returns expanded error correlation matrix for use in dot product with error correlation
+        in other dimensions.
 
-        :param sli: slice of observation variable to return error-correlation matrix for
+        The (sliced) error correlation matrix for this BaseErrCorrForm is expanded from its current
+        (sliced) dimensions (which often don't include all dimensions of the associated uncertainty
+        variable) to the dimensions of the full (sliced) error correlation (i.e. all dimensions of
+        the uncertainty).
+        The returned matrix is not meaningfull unless combined in a dot product with the expanded
+        matrices of other error correlation matrices (together spanning all uncertainty dimensions).
 
-        :return: populated error-correlation matrix
+        :param sli: slice of observation variable to return error-correlation matrix for
+        :return: expanded matrix for use in dot product with error correlation in other dimensions.
         """
-
-        return self.expand_dim_matrix(
-            self.build_matrix(sli), self.get_sliced_dims_errcorr(sli), sli
+        return expand_errcorr_dims(
+            in_corr=self.build_matrix(sli),
+            in_dim=self.get_sliced_dims_errcorr(sli),
+            out_dim=list(self._obj[self._unc_var_name][sli].dims),
+            dim_sizes=self.get_sliced_dim_sizes_uncvar(sli),
         )
 
 
@@ -250,24 +263,14 @@ class ErrCorrMatrixCorrelation(BaseErrCorrForm):
 
         :return: populated error-correlation matrix
         """
-
         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
+        submatrix = self.slice_errcorr_matrix(
+            self._obj[self.params[0]], self.get_varshape_errcorr(), sli_submatrix
         )
 
         return submatrix

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

@@ -7,6 +7,7 @@ from obsarray.err_corr import (
     ErrCorrForms,
     RandomCorrelation,
     SystematicCorrelation,
+    ErrCorrMatrixCorrelation,
 )
 from obsarray.test.test_unc_accessor import create_ds
 
@@ -65,18 +66,26 @@ class TestBaseErrCorrForm(unittest.TestCase):
             form = "basic"
 
             def build_matrix(self, sli):
-                return None
+                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.slice_full_cov(
-            full_matrix, (slice(None), slice(None), slice(None))
+        slice_matrix = basicerrcorr.build_matrix(
+            (slice(None), slice(None), slice(None))
         )
 
         np.testing.assert_equal(full_matrix, slice_matrix)
@@ -118,13 +127,13 @@ class TestBaseErrCorrForm(unittest.TestCase):
         shape = basicerrcorr.get_sliced_shape_errcorr((slice(None), 0, slice(0, 2, 1)))
         assert shape == (2, 2)
 
-    def test_slice_flattened_matrix(self):
+    def test_slice_errcorr_matrix(self):
         basicerrcorr = self.BasicErrCorrForm(
-            self.ds, "u_ran_temperature", ["x"], [], []
+            self.ds, "u_ran_temperature", ["x", "y", "z"], [], []
         )
 
         full_matrix = np.arange(144).reshape((12, 12))
-        slice_matrix = basicerrcorr.slice_flattened_matrix(
+        slice_matrix = basicerrcorr.slice_errcorr_matrix(
             full_matrix, (2, 2, 3), (slice(None), slice(None), 0)
         )
 
@@ -136,13 +145,10 @@ class TestBaseErrCorrForm(unittest.TestCase):
 
     def test_slice_full_cov_slice(self):
         basicerrcorr = self.BasicErrCorrForm(
-            self.ds, "u_ran_temperature", ["x"], [], []
+            self.ds, "u_ran_temperature", ["x", "y", "z"], [], []
         )
 
-        full_matrix = np.arange(144).reshape((12, 12))
-        slice_matrix = basicerrcorr.slice_full_cov(
-            full_matrix, (slice(None), slice(None), 0)
-        )
+        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]]
@@ -206,5 +212,40 @@ class TestSystematicUnc(unittest.TestCase):
         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()

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

@@ -98,7 +98,7 @@ def create_ds():
             "units": "K",
             "err_corr": [
                 {
-                    "dim": "x",
+                    "dim": ["x", "time"],
                     "form": "err_corr_matrix",
                     "params": ["err_corr_str_temperature"],
                 },
@@ -107,19 +107,19 @@ def create_ds():
                     "form": "systematic",
                     "params": [],
                 },
-                {
-                    "dim": "time",
-                    "form": "systematic",
-                    "params": [],
-                },
             ],
             "pdf_shape": "gaussian",
         },
     )
 
     ds["err_corr_str_temperature"] = (
-        ["x", "x"],
-        np.eye(temperature.shape[0]),
+        ["x.time", "x.time"],
+        np.ones(
+            (
+                temperature.shape[0] * temperature.shape[2],
+                temperature.shape[0] * temperature.shape[2],
+            )
+        ),
     )
 
     return ds

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

@@ -354,7 +354,7 @@ class Uncertainty:
         err_cov_matrix = empty_err_corr_matrix(self._obj[self._unc_var_name][self._sli])
 
         err_cov_matrix.values = convert_corr_to_cov(
-            self.err_corr_matrix().values, self.value.values
+            self.err_corr_matrix().values, self.abs_value.values
         )
 
         return err_cov_matrix
@@ -877,7 +877,8 @@ class UncAccessor(object):
                     self._obj[obs_var].attrs["unc_comps"]
                 ]
 
-            self._obj[obs_var].attrs["unc_comps"].append(unc_var)
+            if unc_var not in self._obj[obs_var].attrs["unc_comps"]:
+                self._obj[obs_var].attrs["unc_comps"].append(unc_var)
 
         else:
             self._obj[obs_var].attrs["unc_comps"] = unc_var

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

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

{obsarray-0.2.6 → obsarray-1.0}/obsarray.egg-info/SOURCES.txt

@@ -24,14 +24,12 @@ obsarray.egg-info/requires.txt
 obsarray.egg-info/top_level.txt
 obsarray/templater/__init__.py
 obsarray/templater/dataset_util.py
-obsarray/templater/dsdoc.py
 obsarray/templater/dstemplater.py
 obsarray/templater/dswriter.py
 obsarray/templater/template_util.py
 obsarray/templater/template_util_jon.py
 obsarray/templater/tests/__init__.py
 obsarray/templater/tests/test_dataset_util.py
-obsarray/templater/tests/test_dsdoc.py
 obsarray/templater/tests/test_dswriter.py
 obsarray/templater/tests/test_template_util.py
 obsarray/test/__init__.py

obsarray-0.2.6/obsarray/templater/dsdoc.py

@@ -1,302 +0,0 @@
-"""
-dsdoc - module for documenting defined ds formats
-"""
-
-from obsarray import DSTemplater
-import os
-import numpy as np
-from obsarray.templater.dataset_util import DatasetUtil
-
-
-__author__ = "Sam Hunt <sam.hunt@npl.co.uk>"
-
-
-TEXT = {
-    "title": "Product Data Format",
-    "section_title-introduction": "Introduction",
-    "paragraph-introduction": "This document aims to specify definitions, conventions and formats of the various data "
-    "products generated in the Hypernets land and water network processors.",
-    "section_title-formats": "Product Definitions",
-    "paragraph-formats": "Text",
-    "section_title-dimensions": "Dimension",
-    "paragraph-dimensions": "Text",
-    "section_title-variables": "Variables Definition",
-    "paragraph-variables": "Text",
-    "subsection_title-fmt_variables": "<fmt> Variables",
-    "paragraph-fmt_variables": "<fmt> Text",
-    "section_title-metadata": "Metadata",
-    "paragraph-metadata": "Text",
-    "subsection_title-fmt_metadata": "<fmt> Metadata",
-    "paragraph-fmt_metadata": "<fmt> Text",
-}
-
-
-class RSTDocWriter:
-    def __init__(self):
-        self.doc = []
-
-    def write_doc(self, path):
-        with open(path, "w") as f:
-            for elem in self.doc:
-                f.write(elem + "\n")
-
-    def add_table(self, rows, title, header_widths=None, stub_columns=None):
-        self.doc.append(
-            self.create_table(
-                rows, title, header_widths=header_widths, stub_columns=stub_columns
-            )
-        )
-
-    def add_heading(self, title):
-        self.doc.append(self.create_heading(title))
-
-    def add_subheading(self, title):
-        self.doc.append(self.create_subheading(title))
-
-    def add_subsubheading(self, title):
-        self.doc.append(self.create_subsubheading(title))
-
-    def add_paragraph(self, paragraph):
-        self.doc.append(paragraph + "\n")
-
-    def create_table(self, rows, title, header_widths=None, stub_columns=None):
-
-        rst_table = ".. list-table:: " + str(title) + "\n" "   :header-rows: 1\n"
-
-        if header_widths is not None:
-            widths_string = self.fmt_list_to_str(header_widths)
-            rst_table += "   :widths: " + widths_string + "\n"
-
-        if stub_columns is not None:
-            rst_table += "   :stub-columns: " + str(stub_columns) + "\n"
-
-        rst_table += "\n"
-
-        for row in rows:
-
-            if type(row) != list:
-                row = [row]
-
-            for i, column_value in enumerate(row):
-                if i == 0:
-                    rst_table += "   * - " + str(column_value) + "\n"
-                else:
-                    rst_table += "     - " + str(column_value) + "\n"
-
-        return rst_table
-
-    def _create_rst_heading(self, title, character="="):
-
-        rst_header = title + "\n"
-        rst_header += character * len(title) + "\n"
-
-        return rst_header
-
-    def create_heading(self, title):
-        return self._create_rst_heading(title, character="=")
-
-    def create_subheading(self, title):
-        return self._create_rst_heading(title, character="-")
-
-    def create_subsubheading(self, title):
-        return self._create_rst_heading(title, character="~")
-
-    def fmt_list_to_str(self, lst):
-
-        lst_str = str(lst)
-        lst_str = lst_str.replace("[", "")
-        lst_str = lst_str.replace("]", "")
-        lst_str = lst_str.replace("\\", "")
-        lst_str = lst_str.replace("'", "")
-        return lst_str
-
-
-class DSDoc(RSTDocWriter):
-    def __init__(self, dsb, text=TEXT):
-
-        self.dsb = dsb
-        self.text = text
-        super().__init__()
-
-    def build_dsdoc(self):
-
-        self.add_heading(self.text["title"])
-
-        # Add introduction
-
-        self.add_subheading(self.text["section_title-introduction"])
-        self.add_paragraph(self.text["paragraph-introduction"])
-
-        # Add format
-
-        self.add_subheading(self.text["section_title-formats"])
-        self.add_paragraph(self.text["paragraph-formats"])
-
-        fmt_bullets = ""
-        for fmt in self.dsb.return_ds_formats():
-            fmt_bullets += "* " + fmt + "\n"
-
-        self.add_paragraph(fmt_bullets)
-
-        # Add dimensions section
-
-        self.add_subheading(self.text["section_title-dimensions"])
-        self.add_paragraph(self.text["paragraph-dimensions"])
-        self.add_dims_table()
-
-        # Add variables section
-
-        self.add_subheading(self.text["section_title-variables"])
-        self.add_paragraph(self.text["paragraph-variables"])
-
-        # Add variables subsections per ds_format
-        for fmt in self.dsb.return_ds_formats():
-            self.add_subsubheading(
-                TEXT["subsection_title-fmt_variables"].replace("<fmt>", fmt)
-            )
-            self.add_paragraph(TEXT["paragraph-fmt_variables"].replace("<fmt>", fmt))
-
-            self.add_ds_format_var_tables(fmt)
-
-        # Add metadata section
-        self.add_subheading(TEXT["section_title-metadata"])
-        self.add_paragraph(TEXT["paragraph-metadata"])
-
-        for fmt in self.dsb.return_ds_formats():
-            self.add_subsubheading(
-                TEXT["subsection_title-fmt_metadata"].replace("<fmt>", fmt)
-            )
-            self.add_paragraph(TEXT["paragraph-fmt_metadata"].replace("<fmt>", fmt))
-
-    def add_dims_table(self):
-
-        rows = [["Format", "Dimensions"]]
-
-        for ds_format in self.dsb.return_ds_formats():
-            dims = str(sorted(self.dsb.return_ds_format_dim_names(ds_format)))
-            dims_str = self.fmt_list_to_str(dims)
-
-            rows.append([ds_format, dims_str])
-
-        return self.add_table(rows, "Dimensions")
-
-    def add_ds_format_var_summary_table(self, ds_format):
-
-        rows = [["Variable Name", "Standard Name", "Data Type", "Dimension"]]
-
-        for variable_name in self.dsb.return_ds_format_variable_names(ds_format):
-            variable_dict = self.dsb.return_ds_format_variable_dict(
-                ds_format, variable_name
-            )
-
-            var_dim_str = self.fmt_list_to_str(variable_dict["dim"])
-            var_dtype = self.fmt_dtype_to_str(variable_dict["dtype"])
-
-            var_std_name = None
-            if "attributes" in variable_dict.keys():
-                var_std_name = (
-                    variable_dict["attributes"]["standard_name"]
-                    if "standard_name" in variable_dict["attributes"]
-                    else ""
-                )
-
-            rows.append([variable_name, var_std_name, var_dtype, var_dim_str])
-
-        return self.add_table(rows, ds_format + " variables")
-
-    def add_var_table(self, variable_name, ds_format):
-
-        variable_dict = self.dsb.return_ds_format_variable_dict(
-            ds_format, variable_name
-        )
-
-        rows = [[variable_name, "Attribute", "Value"]]
-
-        fill_value_str = (
-            str(variable_dict["fill_value"])
-            if "fill_value" in variable_dict
-            else str(DatasetUtil.get_default_fill_value(variable_dict["dtype"]))
-        )
-        dtype_str = self.fmt_dtype_to_str(variable_dict["dtype"])
-        var_dim_str = self.fmt_list_to_str(variable_dict["dim"])
-
-        rows.append(["", "dim", var_dim_str])
-        rows.append(["", "dtype", dtype_str])
-
-        if "attributes" in variable_dict.keys():
-            for attribute in variable_dict["attributes"].keys():
-                rows.append(
-                    ["", attribute, str(variable_dict["attributes"][attribute])]
-                )
-
-        rows.append(["", "_FillValue", fill_value_str])
-
-        if "encoding" in variable_dict.keys():
-            for encode in variable_dict["encoding"]:
-
-                encode_str = str(variable_dict["encoding"][encode])
-                if encode == "dtype":
-                    encode_str = self.fmt_dtype_to_str(
-                        variable_dict["encoding"][encode]
-                    )
-
-                rows.append(["", "encoding" + "_" + encode, encode_str])
-
-        return self.add_table(rows, variable_name + " definition", stub_columns=1)
-
-    def add_ds_format_var_tables(self, ds_format):
-
-        self.add_ds_format_var_summary_table(ds_format)
-
-        for variable_name in self.dsb.return_ds_format_variable_names(ds_format):
-            self.add_var_table(variable_name, ds_format)
-
-    def fmt_dtype_to_str(self, dtype):
-
-        if dtype == np.int8:
-            return "int8"
-        if dtype == np.uint8:
-            return "uint8"
-        elif dtype == np.int16:
-            return "int16"
-        elif dtype == np.uint16:
-            return "uint16"
-        elif dtype == np.int32:
-            return "int32"
-        elif dtype == np.uint32:
-            return "uint32"
-        elif dtype == np.int64:
-            return "int64"
-        elif dtype == np.float32:
-            return "float32"
-        elif dtype == np.float64:
-            return "float64"
-        elif dtype == int:
-            return "int"
-        elif dtype == float:
-            return "float"
-
-
-def dsdoc_main(path, variables_defs, metadata_defs, custom_text=None):
-
-    # Setup
-    dsb = DSBuilder(variables_defs=variables_defs, metadata_defs=metadata_defs)
-
-    if custom_text is not None:
-        TEXT.update(custom_text)
-
-    dsdoc = DSDoc(dsb, text=TEXT)
-
-    # Build docs
-    dsdoc.build_dsdoc()
-
-    # Write docs
-    outdir = os.path.dirname(path)
-    if not os.path.exists(outdir):
-        os.mkdir(outdir)
-
-    dsdoc.write_doc(os.path.join(outdir, "format.rst"))
-
-
-if __name__ == "__main__":
-    pass

obsarray-0.2.6/obsarray/templater/tests/test_dsdoc.py

@@ -1,312 +0,0 @@
-# """
-# Tests for DatasetUtil class
-# """
-#
-# import unittest
-# from unittest.mock import patch, call
-# from obsarray import DSTemplater
-# from obsarray.templater.dsdoc import RSTDocWriter, DSDoc, dsdoc_main
-# import numpy as np
-#
-# """___Authorship___"""
-# __author__ = "Sam Hunt"
-# __created__ = "17/9/2020"
-#
-#
-# TEST_TEXT = {
-#     "title": "Product Data Format",
-#     "section_title-introduction": "Introduction",
-#     "paragraph-introduction": "Text",
-#     "section_title-formats": "Formats",
-#     "paragraph-formats": "Text",
-#     "section_title-dimensions": "Dimension",
-#     "paragraph-dimensions": "Text",
-#     "section_title-variables": "Variables Definition",
-#     "paragraph-variables": "Text",
-#     "subsection_title-fmt_variables": "<fmt> Variables",
-#     "paragraph-fmt_variables": "<fmt> Text",
-#     "section_title-metadata": "Metadata",
-#     "paragraph-metadata": "Text",
-#     "subsection_title-fmt_metadata": "<fmt> Metadata",
-#     "paragraph-fmt_metadata": "<fmt> Text",
-# }
-#
-# array_variable1_rows = [
-#     ["array_variable1", "Attribute", "Value"],
-#     ["", "dim", "dim1, dim2"],
-#     ["", "dtype", "float32"],
-#     ["", "standard_name", "array_variable_std_name1"],
-#     ["", "long_name", "array_variable_long_name1"],
-#     ["", "units", "units"],
-#     ["", "preferred_symbol", "av"],
-#     ["", "_FillValue", "9.96921e+36"],
-#     ["", "encoding_dtype", "uint16"],
-#     ["", "encoding_scale_factor", "1.0"],
-#     ["", "encoding_offset", "0.0"],
-# ]
-#
-# array_variable2_rows = [
-#     ["array_variable2", "Attribute", "Value"],
-#     ["", "dim", "dim3, dim4"],
-#     ["", "dtype", "float32"],
-#     ["", "standard_name", "array_variable_std_name2"],
-#     ["", "long_name", "array_variable_long_name2"],
-#     ["", "units", "units"],
-#     ["", "preferred_symbol", "av"],
-#     ["", "_FillValue", "9.96921e+36"],
-#     ["", "encoding_dtype", "uint16"],
-#     ["", "encoding_scale_factor", "1.0"],
-#     ["", "encoding_offset", "0.0"],
-# ]
-#
-#
-# def setup_variables_defs():
-#     test_variables = {
-#         "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},
-#         },
-#     }
-#
-#     return {"def1": test_variables}
-#
-#
-# def setup_metadata_defs():
-#     return {}
-#
-#
-# def setup_dsb(
-#     templates=setup_variables_defs(), metadata_defs=setup_metadata_defs()
-# ):
-#     return DSTemplater(templates=templates, metadata_defs=metadata_defs)
-#
-#
-# class TestRSTDocWriter(unittest.TestCase):
-#     def test_create_table(self):
-#         dw = RSTDocWriter()
-#
-#         rows = [["test1", "test2", "test3"], ["test4", "test5", "test6"]]
-#         title = "table title"
-#         spacing = [30, 40, 30]
-#
-#         tbl = dw.create_table(rows, title, spacing)
-#         expected_tbl = (
-#             ".. list-table:: table title\n"
-#             "   :header-rows: 1\n"
-#             "   :widths: 30 40 30\n\n"
-#             "   * - test1\n"
-#             "     - test2\n"
-#             "     - test3\n"
-#             "   * - test4\n"
-#             "     - test5\n"
-#             "     - test6\n"
-#         )
-#
-#         self.assertEqual(tbl, expected_tbl)
-#
-#     def test_create_table_single_column(self):
-#         dw = RSTDocWriter()
-#
-#         rows = ["test1", "test2", "test3"]
-#         title = "table title"
-#
-#         tbl = dw.create_table(rows, title)
-#         expected_tbl = (
-#             ".. list-table:: table title\n"
-#             "   :header-rows: 1\n\n"
-#             "   * - test1\n"
-#             "   * - test2\n"
-#             "   * - test3\n"
-#         )
-#
-#         self.assertEqual(tbl, expected_tbl)
-#
-#     def test__create_rst_heading(self):
-#         dw = RSTDocWriter()
-#
-#         heading = dw._create_rst_heading("text", "=")
-#         expected_heading = "text\n" "====\n"
-#
-#         self.assertEqual(heading, expected_heading)
-#
-#     @patch("templater.dsdoc.RSTDocWriter.create_table")
-#     def test_add_table(self, mock):
-#         dw = RSTDocWriter()
-#         dw.add_table("rows", "title", "widths")
-#         mock.assert_called_once_with("rows", "title", header_widths="widths")
-#
-#         self.assertEqual(dw.doc[0], mock.return_value)
-#
-#     @patch("templater.dsdoc.RSTDocWriter._create_rst_heading")
-#     def test_create_heading(self, mock):
-#         dw = RSTDocWriter()
-#         heading = dw.create_heading("text")
-#         mock.assert_called_once_with("text", character="=")
-#
-#     @patch("templater.dsdoc.RSTDocWriter._create_rst_heading")
-#     def test_create_subheading(self, mock):
-#         dw = RSTDocWriter()
-#         heading = dw.create_subheading("text")
-#         mock.assert_called_once_with("text", character="-")
-#
-#     @patch("templater.dsdoc.RSTDocWriter._create_rst_heading")
-#     def test_create_subsubheading(self, mock):
-#         dw = RSTDocWriter()
-#         heading = dw.create_subsubheading("text")
-#         mock.assert_called_once_with("text", character="~")
-#
-#     @patch("templater.dsdoc.RSTDocWriter.create_heading")
-#     def test_add_heading(self, mock):
-#         dw = RSTDocWriter()
-#         dw.add_heading("text")
-#         mock.assert_called_once_with("text")
-#
-#         self.assertEqual(dw.doc[0], mock.return_value)
-#
-#     @patch("templater.dsdoc.RSTDocWriter.create_subheading")
-#     def test_add_subheading(self, mock):
-#         dw = RSTDocWriter()
-#         heading = dw.add_subheading("text")
-#         mock.assert_called_once_with("text")
-#
-#         self.assertEqual(dw.doc[0], mock.return_value)
-#
-#     @patch("templater.dsdoc.RSTDocWriter.create_subsubheading")
-#     def test_add_subsubheading(self, mock):
-#         dw = RSTDocWriter()
-#         dw.add_subsubheading("text")
-#         mock.assert_called_once_with("text")
-#
-#         self.assertEqual(dw.doc[0], mock.return_value)
-#
-#     def test_add_paragraph(self):
-#         dw = RSTDocWriter()
-#         dw.add_paragraph("text")
-#
-#         self.assertEqual(dw.doc[0], "text" + "\n")
-#
-#
-# class TestDSDoc(unittest.TestCase):
-#     @patch("templater.dsdoc.RSTDocWriter.add_table")
-#     def test_build_dims_table(self, mock):
-#
-#         dsb = setup_dsb()
-#         dsdoc = DSDoc(dsb)
-#
-#         dsdoc.add_dims_table()
-#
-#         expected_rows = [["Format", "Dimensions"], ["def1", "dim1, dim2, dim3, dim4"]]
-#         expected_title = "Dimensions"
-#
-#         mock.assert_called_once_with(expected_rows, expected_title)
-#
-#     @patch("templater.dsdoc.DSDoc.add_var_table")
-#     def test_add_ds_format_var_tables(self, mock):
-#         dsb = setup_dsb()
-#         dsdoc = DSDoc(dsb)
-#
-#         dsdoc.add_ds_format_var_tables("def1")
-#
-#         calls = [call("array_variable1", "def1"), call("array_variable2", "def1")]
-#
-#         self.assertCountEqual(mock.call_args_list, calls)
-#
-#     @patch("templater.dsdoc.RSTDocWriter.add_table")
-#     def test_build_var_table(self, mock):
-#         dsb = setup_dsb()
-#         dsdoc = DSDoc(dsb)
-#
-#         dsdoc.add_var_table("array_variable1", "def1")
-#
-#         expected_rows = array_variable1_rows
-#         expected_title = "array_variable1 definition"
-#
-#         mock.assert_called_once_with(expected_rows, expected_title, stub_columns=1)
-#
-#     @patch("templater.dsdoc.RSTDocWriter.add_table")
-#     def test_add_ds_format_var_summary_table(self, mock):
-#         dsb = setup_dsb()
-#         dsdoc = DSDoc(dsb)
-#
-#         dsdoc.add_ds_format_var_summary_table("def1")
-#
-#         expected_rows = [
-#             ["Variable Name", "Standard Name", "Data Type", "Dimension"],
-#             ["array_variable1", "array_variable_std_name1", "float32", "dim1, dim2"],
-#             ["array_variable2", "array_variable_std_name2", "float32", "dim3, dim4"],
-#         ]
-#         expected_title = "def1 variables"
-#
-#         mock.assert_called_once_with(expected_rows, expected_title)
-#
-#     def test_build_dsdoc(self):
-#
-#         dsb = setup_dsb()
-#         dsdoc = DSDoc(dsb, text=TEST_TEXT)
-#
-#         dsdoc.build_dsdoc()
-#
-#         dsdoc_mk = DSDoc(dsb, text=TEST_TEXT)
-#         dsdoc_mk.add_ds_format_var_summary_table("def1")
-#         dsdoc_mk.add_dims_table()
-#         def1_summary_tbl = dsdoc_mk.doc[0]
-#         dims_tbl = dsdoc_mk.doc[1]
-#
-#         expected_doc = [
-#             "Product Data Format\n===================\n",
-#             "Formats\n-------\n",
-#             "Text\n",
-#             "* def1\n",
-#             "Introduction\n------------\n",
-#             "Text\n",
-#             "Dimension\n---------\n",
-#             "Text\n",
-#             dims_tbl,
-#             "Variables Definition\n--------------------\n",
-#             "Text\n",
-#             "def1 Variables\n~~~~~~~~~~~~~~\n",
-#             "def1 Text\n",
-#             def1_summary_tbl,
-#             dsdoc.create_table(
-#                 array_variable1_rows, "array_variable1 definition", stub_columns=1
-#             ),
-#             dsdoc.create_table(
-#                 array_variable2_rows, "array_variable2 definition", stub_columns=1
-#             ),
-#             "Metadata\n--------\n",
-#             "Text\n",
-#             "def1 Metadata\n~~~~~~~~~~~~~\n",
-#             "def1 Text\n",
-#         ]
-#
-#         self.assertCountEqual(expected_doc, dsdoc.doc)
-#
-#     def test_write_dsdoc(self):
-#
-#         dsb = setup_dsb()
-#         dsdoc = DSDoc(dsb, text=TEST_TEXT)
-#
-#         dsdoc.build_dsdoc()
-#         dsdoc.write_doc("dsdoc/src/ds.rst")
-#
-#
-# if __name__ == "__main__":
-#     unittest.main()