h5yaml 0.0.3__py3-none-any.whl

h5yaml/Data/h5_testing.yaml

@@ -0,0 +1,99 @@
+# YAML
+#
+# Configuration file to test the implementation of classes H5Yaml and NcYaml
+#
+# This file is part of h5_yaml:
+#    https://github.com/rmvanhees/h5_yaml.git
+#
+# Copyright (c) 2025 SRON
+#    All Rights Reserved
+#
+# License:  BSD-3-Clause
+#
+# Define groups
+groups:
+  - group_00
+  - group_01
+  - group_02
+
+# Define dimensions
+# Note dimensions with an attribute 'long_name' will also be generated as variable
+dimensions:
+  number_of_images:
+    _dtype: u2
+    _size: 0
+  samples_per_image:
+    _dtype: u4
+    _size: 203500
+  column:
+    _dtype: u2
+    _size: 640
+  row:
+    _dtype: u2
+    _size: 512
+  time:
+    _dtype: f8
+    _size: 0
+    _FillValue: -32767
+    long_name: Attitude sample time (seconds of day)
+    calendar: proleptic_gregorian
+    units: seconds since %Y-%m-%d %H:%M:%S
+    valid_min: 0
+    valid_max: 92400
+
+# Define compound types
+# - compound elements must have a data-type, and can have a unit and long_name 
+compounds:
+  stats_dtype:
+    time: [u8, seconds since 1970-01-01T00:00:00, timestamp]
+    index: [u2, '1', index]
+    tbl_id: [u1, '1', binning id]
+    saa: [u1, '1', saa-flag]
+    coad: [u1, '1', co-addings]
+    texp: [f4, ms, exposure time]
+    lat: [f4, degree, latitude]
+    lon: [f4, degree, longitude]
+    avg: [f4, '1', '$S - S_{ref}$']
+    unc: [f4, '1', '\u03c3($S - S_{ref}$)']
+    dark_offs: [f4, '1', dark-offset]
+
+  geo_dtype:
+    lat: [f4, latitude]
+    lon: [f4, longitude]
+    
+# Define variables
+variables:
+  /group_00/detector_images:
+    _dtype: u2
+    _dims: [number_of_images, column, row]
+    _FillValue: 65535
+    long_name: Detector pixel values
+    comment: unbinned full-frame data
+    units: '1'
+    valid_min: 0
+    valid_max: 65534
+  /group_01/detector_images:
+    _dtype: u2
+    _dims: [number_of_images, samples_per_image]
+    _FillValue: 65535
+    _compression: 1
+    long_name: Detector pixel values
+    comment: variable binned data (filled to the largest samples_per_image)
+    units: '1'
+    valid_min: 0
+    valid_max: 65534
+  /group_01/stats:
+    _dtype: stats_dtype
+    _vlen: True
+    _dims: [time]
+    comment: detector map statistics
+  /group_02/detector_images:
+    _dtype: u2
+    _dims: [number_of_images]
+    _vlen: True
+    _FillValue: 65535
+    long_name: Detector pixel values
+    comment: variable binned (vlen) data
+    units: '1'
+    valid_min: 0
+    valid_max: 65534

h5yaml/conf_from_yaml.py

@@ -0,0 +1,48 @@
+#
+# This file is part of h5_yaml:
+#    https://github.com/rmvanhees/h5_yaml.git
+#
+# Copyright (c) 2025 SRON
+#    All Rights Reserved
+#
+# License:  BSD-3-Clause
+#
+"""Read settings from a YAML file."""
+
+from __future__ import annotations
+
+__all__ = ["conf_from_yaml"]
+
+from typing import TYPE_CHECKING
+
+import yaml
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+# - main function -----------------------------------
+def conf_from_yaml(file_path: Path) -> dict:
+    """Read settings from a YAML file: `file_path`.
+
+    Parameters
+    ----------
+    file_path :  Path
+       full path of YAML file
+
+    Returns
+    -------
+    dict
+       content of the configuration file
+
+    """
+    if not file_path.is_file():
+        raise FileNotFoundError(f"{file_path} not found")
+
+    with file_path.open("r", encoding="ascii") as fid:
+        try:
+            settings = yaml.safe_load(fid)
+        except yaml.YAMLError as exc:
+            raise RuntimeError from exc
+
+    return settings

h5yaml/lib/chunksizes.py

@@ -0,0 +1,54 @@
+#
+# This file is part of h5_yaml
+#    https://github.com/rmvanhees/h5_yaml.git
+#
+# Copyright (c) 2025 SRON
+#    All Rights Reserved
+#
+# License:  BSD-3-Clause
+#
+"""Obtain chunksizes for HDF5 datasets."""
+
+from __future__ import annotations
+
+__all__ = ["guess_chunks"]
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from numpy.typing import ArrayLike
+
+
+def guess_chunks(dims: ArrayLike[int], dtype_sz: int) -> str | tuple[int]:
+    """Perform an educated guess for the dataset chunk sizes.
+
+    Parameters
+    ----------
+    dims :  ArrayLike[int]
+       Dimensions of the variable
+    dtype_sz :  int
+       The element size of the data-type of the variable
+
+    Returns
+    -------
+    "contiguous" or tuple with chunk-sizes
+
+    """
+    fixed_size = dtype_sz
+    for val in [x for x in dims if x > 0]:
+        fixed_size *= val
+
+    if 0 in dims:  # variable with an unlimited dimension
+        udim = dims.index(0)
+    else:  # variable has no unlimited dimension
+        udim = 0
+        if fixed_size < 65536:
+            return "contiguous"
+
+    if len(dims) == 1:
+        return (1024,)
+
+    res = list(dims)
+    res[udim] = min(1024, (2048 * 1024) // (fixed_size // max(1, dims[0])))
+
+    return tuple(res)

h5yaml/yaml_h5py.py

@@ -0,0 +1,259 @@
+#
+# This file is part of h5_yaml
+#    https://github.com/rmvanhees/h5_yaml.git
+#
+# Copyright (c) 2025 SRON
+#    All Rights Reserved
+#
+# License:  BSD-3-Clause
+#
+"""Create HDF5/netCDF4 formatted file from a YAML configuration file using h5py."""
+
+from __future__ import annotations
+
+__all__ = ["H5Yaml"]
+
+import logging
+from importlib.resources import files
+from pathlib import Path
+
+import h5py
+import numpy as np
+
+from h5yaml.conf_from_yaml import conf_from_yaml
+from h5yaml.lib.chunksizes import guess_chunks
+
+
+# - class definition -----------------------------------
+class H5Yaml:
+    """Class to create a HDF5/netCDF4 formated file from a YAML configuration file.
+
+    Parameters
+    ----------
+    h5_yaml_fl :  Path
+       YAML files with the HDF5 format definition
+
+    """
+
+    def __init__(self: H5Yaml, h5_yaml_fl: Path) -> None:
+        """Construct a H5Yaml instance."""
+        self.logger = logging.getLogger("h5yaml.H5Yaml")
+
+        try:
+            self._h5_def = conf_from_yaml(h5_yaml_fl)
+        except RuntimeError as exc:
+            raise RuntimeError from exc
+
+        self.yaml_dir = h5_yaml_fl.parent
+
+    def __groups(self: H5Yaml, fid: h5py.File) -> None:
+        """Create groups in HDF5 product."""
+        for key in self.h5_def["groups"]:
+            _ = fid.create_group(key)
+
+    def __dimensions(self: H5Yaml, fid: h5py.File) -> None:
+        """Add dimensions to HDF5 product."""
+        for key, value in self.h5_def["dimensions"].items():
+            fillvalue = None
+            if "_FillValue" in value:
+                fillvalue = (
+                    np.nan if value["_FillValue"] == "NaN" else int(value["_FillValue"])
+                )
+
+            if value["_size"] == 0:
+                ds_chunk = value.get("_chunks", (50,))
+                dset = fid.create_dataset(
+                    key,
+                    shape=(0,),
+                    dtype=(
+                        h5py.string_dtype()
+                        if value["_dtype"] == "str"
+                        else value["_dtype"]
+                    ),
+                    chunks=ds_chunk if isinstance(ds_chunk, tuple) else tuple(ds_chunk),
+                    maxshape=(None,),
+                    fillvalue=fillvalue,
+                )
+            else:
+                dset = fid.create_dataset(
+                    key,
+                    shape=(value["_size"],),
+                    dtype=value["_dtype"],
+                )
+                if "_values" in value:
+                    dset[:] = value["_values"]
+
+            dset.make_scale(
+                Path(key).name
+                if "long_name" in value
+                else "This is a netCDF dimension but not a netCDF variable."
+            )
+            for attr, attr_val in value.items():
+                if attr.startswith("_"):
+                    continue
+                dset.attrs[attr] = attr_val
+
+    def __compounds(self: H5Yaml, fid: h5py.File) -> dict[str, str | int | float]:
+        """Add compound datatypes to HDF5 product."""
+        if "compounds" not in self.h5_def:
+            return {}
+
+        compounds = {}
+        if isinstance(self.h5_def["compounds"], list):
+            file_list = self.h5_def["compounds"].copy()
+            self.h5_def["compounds"] = {}
+            for name in file_list:
+                if not (yaml_fl := self.yaml_dir / name).is_file():
+                    continue
+                try:
+                    res = conf_from_yaml(yaml_fl)
+                except RuntimeError as exc:
+                    raise RuntimeError from exc
+                for key, value in res.items():
+                    self.h5_def["compounds"][key] = value
+
+        for key, value in self.h5_def["compounds"].items():
+            compounds[key] = {
+                "dtype": [],
+                "units": [],
+                "names": [],
+            }
+
+            for _key, _val in value.items():
+                compounds[key]["dtype"].append((_key, _val[0]))
+                if len(_val) == 3:
+                    compounds[key]["units"].append(_val[1])
+                compounds[key]["names"].append(_val[2] if len(_val) == 3 else _val[1])
+
+            fid[key] = np.dtype(compounds[key]["dtype"])
+
+        return compounds
+
+    def __variables(
+        self: H5Yaml, fid: h5py.File, compounds: dict[str, str | int | float] | None
+    ) -> None:
+        """Add datasets to HDF5 product.
+
+        Parameters
+        ----------
+        fid :  h5py.File
+           HDF5 file pointer (mode 'r+')
+        compounds :  dict[str, str | int | float]
+           Definition of the compound(s) in the product
+
+        """
+        for key, val in self.h5_def["variables"].items():
+            if val["_dtype"] in fid:
+                ds_dtype = fid[val["_dtype"]]
+                dtype_size = fid[val["_dtype"]].dtype.itemsize
+            else:
+                ds_dtype = val["_dtype"]
+                dtype_size = np.dtype(val["_dtype"]).itemsize
+
+            fillvalue = None
+            if "_FillValue" in val:
+                fillvalue = (
+                    np.nan if val["_FillValue"] == "NaN" else int(val["_FillValue"])
+                )
+
+            compression = None
+            shuffle = False
+            # currently only gzip compression is supported
+            if "_compression" in val:
+                compression = val["_compression"]
+                shuffle = True
+
+            n_udim = 0
+            ds_shape = ()
+            ds_maxshape = ()
+            for coord in val["_dims"]:
+                dim_sz = fid[coord].size
+                n_udim += int(dim_sz == 0)
+                ds_shape += (dim_sz,)
+                ds_maxshape += (dim_sz if dim_sz > 0 else None,)
+
+            # currently, we can not handle more than one unlimited dimension
+            if n_udim > 1:
+                raise ValueError("more than one unlimited dimension")
+
+            # obtain chunk-size settings
+            ds_chunk = (
+                val["_chunks"]
+                if "_chunks" in val
+                else guess_chunks(ds_shape, dtype_size)
+            )
+
+            # create the variable
+            if ds_chunk == "contiguous":
+                dset = fid.create_dataset(
+                    key,
+                    ds_shape,
+                    dtype=ds_dtype,
+                    chunks=None,
+                    maxshape=None,
+                    fillvalue=fillvalue,
+                )
+            else:
+                if val.get("_vlen"):
+                    ds_dtype = h5py.vlen_dtype(ds_dtype)
+                    fillvalue = None
+                    if ds_maxshape == (None,):
+                        ds_chunk = (16,)
+
+                dset = fid.create_dataset(
+                    key,
+                    ds_shape,
+                    dtype=ds_dtype,
+                    chunks=ds_chunk if isinstance(ds_chunk, tuple) else tuple(ds_chunk),
+                    maxshape=ds_maxshape,
+                    fillvalue=fillvalue,
+                    compression=compression,
+                    shuffle=shuffle,
+                )
+
+            for ii, coord in enumerate(val["_dims"]):
+                dset.dims[ii].attach_scale(fid[coord])
+
+            for attr, attr_val in val.items():
+                if attr.startswith("_"):
+                    continue
+                dset.attrs[attr] = attr_val
+
+            if compounds is not None and val["_dtype"] in compounds:
+                if compounds[val["_dtype"]]["units"]:
+                    dset.attrs["units"] = compounds[val["_dtype"]]["units"]
+                if compounds[val["_dtype"]]["names"]:
+                    dset.attrs["long_name"] = compounds[val["_dtype"]]["names"]
+
+    @property
+    def h5_def(self: H5Yaml) -> dict:
+        """Return definition of the HDF5/netCDF4 product."""
+        return self._h5_def
+
+    def create(self: H5Yaml, l1a_name: Path | str) -> None:
+        """Create a HDF5/netCDF4 file (overwrite if exist).
+
+        Parameters
+        ----------
+        l1a_name :  Path | str
+           Full name of the HDF5/netCDF4 file to be generated
+
+        """
+        try:
+            with h5py.File(l1a_name, "w") as fid:
+                self.__groups(fid)
+                self.__dimensions(fid)
+                self.__variables(fid, self.__compounds(fid))
+        except PermissionError as exc:
+            raise RuntimeError(f"failed create {l1a_name}") from exc
+
+
+# - test module -------------------------
+def tests() -> None:
+    """..."""
+    print("Calling H5Yaml")
+    H5Yaml(files("h5yaml.Data") / "h5_testing.yaml").create("test_yaml.h5")
+
+
+if __name__ == "__main__":
+    tests()

h5yaml/yaml_nc.py

@@ -0,0 +1,238 @@
+#
+# This file is part of h5_yaml:
+#    https://github.com/rmvanhees/h5_yaml.git
+#
+# Copyright (c) 2025 SRON
+#    All Rights Reserved
+#
+# License:  BSD-3-Clause
+#
+"""Create HDF5/netCDF4 formatted file from a YAML configuration file using netCDF4."""
+
+from __future__ import annotations
+
+__all__ = ["NcYaml"]
+
+import logging
+from importlib.resources import files
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+# pylint: disable=no-name-in-module
+from netCDF4 import Dataset
+
+from h5yaml.conf_from_yaml import conf_from_yaml
+from h5yaml.lib.chunksizes import guess_chunks
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+# - class definition -----------------------------------
+class NcYaml:
+    """Class to create a HDF5/netCDF4 formated file from a YAML configuration file."""
+
+    def __init__(self: NcYaml, h5_yaml_fl: Path) -> None:
+        """Construct a NcYaml instance."""
+        self.logger = logging.getLogger("h5yaml.NcYaml")
+
+        try:
+            self._h5_def = conf_from_yaml(h5_yaml_fl)
+        except RuntimeError as exc:
+            raise RuntimeError from exc
+
+        self.yaml_dir = h5_yaml_fl.parent
+
+    def __groups(self: NcYaml, fid: Dataset) -> None:
+        """Create groups in HDF5 product."""
+        for key in self.h5_def["groups"]:
+            _ = fid.createGroup(key)
+
+    def __dimensions(self: NcYaml, fid: Dataset) -> None:
+        """Add dimensions to HDF5 product."""
+        for key, value in self.h5_def["dimensions"].items():
+            _ = fid.createDimension(key, value["_size"])
+
+            if "long_name" not in value:
+                continue
+
+            fillvalue = None
+            if "_FillValue" in value:
+                fillvalue = (
+                    np.nan if value["_FillValue"] == "NaN" else int(value["_FillValue"])
+                )
+
+            dset = fid.createVariable(
+                key,
+                value["_dtype"],
+                dimensions=(key,),
+                fill_value=fillvalue,
+                contiguous=value["_size"] != 0,
+            )
+            dset.setncatts({k: v for k, v in value.items() if not k.startswith("_")})
+
+    def __compounds(self: NcYaml, fid: Dataset) -> dict[str, str | int | float]:
+        """Add compound datatypes to HDF5 product."""
+        if "compounds" not in self.h5_def:
+            return {}
+
+        compounds = {}
+        if isinstance(self.h5_def["compounds"], list):
+            file_list = self.h5_def["compounds"].copy()
+            self.h5_def["compounds"] = {}
+            for name in file_list:
+                if not (yaml_fl := self.yaml_dir / name).is_file():
+                    continue
+                try:
+                    res = conf_from_yaml(yaml_fl)
+                except RuntimeError as exc:
+                    raise RuntimeError from exc
+                for key, value in res.items():
+                    self.h5_def["compounds"][key] = value
+
+        for key, value in self.h5_def["compounds"].items():
+            compounds[key] = {
+                "dtype": [],
+                "units": [],
+                "names": [],
+            }
+
+            for _key, _val in value.items():
+                compounds[key]["dtype"].append((_key, _val[0]))
+                if len(_val) == 3:
+                    compounds[key]["units"].append(_val[1])
+                compounds[key]["names"].append(_val[2] if len(_val) == 3 else _val[1])
+
+            comp_t = np.dtype(compounds[key]["dtype"])
+            _ = fid.createCompoundType(comp_t, key)
+
+        return compounds
+
+    def __variables(
+        self: NcYaml,
+        fid: Dataset,
+        compounds: dict[str, str | int | float] | None,
+    ) -> None:
+        """Add datasets to HDF5 product.
+
+        Parameters
+        ----------
+        fid :  netCDF4.Dataset
+           HDF5 file pointer (mode 'r+')
+        compounds :  dict[str, str | int | float]
+           Definition of the compound(s) in the product
+
+        """
+        for key, val in self.h5_def["variables"].items():
+            if val["_dtype"] in fid.cmptypes:
+                ds_dtype = fid.cmptypes[val["_dtype"]].dtype
+                sz_dtype = ds_dtype.itemsize
+            else:
+                ds_dtype = val["_dtype"]
+                sz_dtype = np.dtype(val["_dtype"]).itemsize
+
+            fillvalue = None
+            if "_FillValue" in val:
+                fillvalue = (
+                    np.nan if val["_FillValue"] == "NaN" else int(val["_FillValue"])
+                )
+
+            compression = None
+            complevel = 0
+            # currently only gzip compression is supported
+            if "_compression" in val:
+                compression = "zlib"
+                complevel = val["_compression"]
+
+            n_udim = 0
+            ds_shape = ()
+            ds_maxshape = ()
+            for coord in val["_dims"]:
+                dim_sz = fid.dimensions[coord].size
+                n_udim += int(dim_sz == 0)
+                ds_shape += (dim_sz,)
+                ds_maxshape += (dim_sz if dim_sz > 0 else None,)
+
+            # currently, we can not handle more than one unlimited dimension
+            if n_udim > 1:
+                raise ValueError("more than one unlimited dimension")
+
+            # obtain chunk-size settings
+            ds_chunk = (
+                val["_chunks"] if "_chunks" in val else guess_chunks(ds_shape, sz_dtype)
+            )
+
+            # create the variable
+            if ds_chunk == "contiguous":
+                dset = fid.createVariable(
+                    key,
+                    val["_dtype"],
+                    dimensions=(key,),
+                    fill_value=fillvalue,
+                    contiguous=True,
+                )
+            else:
+                if val.get("_vlen"):
+                    if val["_dtype"] in fid.cmptypes:
+                        raise ValueError("can not have vlen with compounds")
+                    val["_dtype"] = fid.createVLType(ds_dtype, val["_dtype"])
+                    fillvalue = None
+                    if ds_maxshape == (None,):
+                        ds_chunk = (16,)
+
+                if key in fid.cmptypes:
+                    val["_dtype"] = fid.cmptypes[key]
+
+                dset = fid.createVariable(
+                    key,
+                    val["_dtype"],
+                    dimensions=val["_dims"],
+                    fill_value=fillvalue,
+                    contiguous=False,
+                    compression=compression,
+                    complevel=complevel,
+                    chunksizes=(
+                        ds_chunk if isinstance(ds_chunk, tuple) else tuple(ds_chunk)
+                    ),
+                )
+            dset.setncatts({k: v for k, v in val.items() if not k.startswith("_")})
+
+            if compounds is not None and val["_dtype"] in compounds:
+                if compounds[val["_dtype"]]["units"]:
+                    dset.attrs["units"] = compounds[val["_dtype"]]["units"]
+                if compounds[val["_dtype"]]["names"]:
+                    dset.attrs["long_name"] = compounds[val["_dtype"]]["names"]
+
+    @property
+    def h5_def(self: NcYaml) -> dict:
+        """Return definition of the HDF5/netCDF4 product."""
+        return self._h5_def
+
+    def create(self: NcYaml, l1a_name: Path | str) -> None:
+        """Create a HDF5/netCDF4 file (overwrite if exist).
+
+        Parameters
+        ----------
+        l1a_name :  Path | str
+           Full name of the HDF5/netCDF4 file to be generated
+
+        """
+        try:
+            with Dataset(l1a_name, "w") as fid:
+                self.__groups(fid)
+                self.__dimensions(fid)
+                self.__variables(fid, self.__compounds(fid))
+        except PermissionError as exc:
+            raise RuntimeError(f"failed create {l1a_name}") from exc
+
+
+# - test module -------------------------
+def tests() -> None:
+    """..."""
+    print("Calling NcYaml")
+    NcYaml(files("h5yaml.Data") / "h5_testing.yaml").create("test_yaml.nc")
+
+
+if __name__ == "__main__":
+    tests()

h5yaml-0.0.3.dist-info/METADATA

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: h5yaml
+Version: 0.0.3
+Summary: Use YAML configuration file to generate HDF5/netCDF4 formated files.
+Project-URL: Homepage, https://github.com/rmvanhees/h5_yaml
+Project-URL: Source, https://github.com/rmvanhees/h5_yaml
+Project-URL: Issues, https://github.com/rmvanhees/h5_yaml/issues
+Author-email: Richard van Hees <r.m.van.hees@sron.nl>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: HDF5,YAML,netCDF4
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
+Requires-Python: >=3.12
+Requires-Dist: h5py>=3.13
+Requires-Dist: netcdf4>=1.7
+Requires-Dist: numpy>=2.2
+Requires-Dist: pyyaml>=6.0
+Description-Content-Type: text/markdown
+
+# H5_YAML
+
+## Description
+Use YAML configuration file to generate HDF5/netCDF4 formated files.
+
+The class `NcYaml` must be used when strict conformance to the netCDF4 format is
+required. However, the python netCDF4 implementation does not allow variable-length
+data to have a compound data-type. The class `H5Yaml` does not have this restiction
+and will generate HDF5 formated files which can be read by netCDF4 software.
+
+## Installation
+Relases of the code, starting from version 0.1, will be made available via PyPi.
+
+## Usage
+
+The YAML file should be structured as follows:
+
+ * The top level are: 'groups', 'dimensions', 'compounds' and 'variables'
+ * The section 'groups' are optional, but you should provide each group you want to use
+   in your file. The 'groups' section in the YAML file may look like this:
+
+   ```
+   groups:
+     - engineering_data
+     - image_attributes
+     - navigation_data
+     - processing_control
+     - science_data
+   ```
+
+ * The section 'dimensions' is obligatory, you shouold define the dimensions for each
+   variable in your file. The 'dimensions' section may look like this:
+
+   ```
+   dimensions:
+     days:
+       _dtype: u4
+       _size: 0
+       long_name: days since 2024-01-01 00:00:00Z
+     number_of_images:             # an unlimited dimension
+       _dtype: u2
+       _size: 0
+     samples_per_image:            # a fixed dimension
+       _dtype: u4
+       _size: 307200
+     /navigation_data/att_time:    # an unlimited dimension in a group with attributes
+       _dtype: f8
+       _size: 0
+       _FillValue: -32767
+       long_name: Attitude sample time (seconds of day)
+       calendar: proleptic_gregorian
+       units: seconds since %Y-%m-%d %H:%M:%S
+       valid_min: 0
+       valid_max: 92400
+     n_viewport:                   # a fixed dimension with fixed values and attributes
+       _dtype: i2
+       _size: 5
+       _values: [-50, -20, 0, 20, 50]
+       long_name: along-track view angles at sensor
+       units: degrees
+   ```
+
+ * The 'compounds' are optional, but you should provide each compound data-type which
+   you want to use in your file. For each compound element you have to provide its
+   data-type and attributes: units and long_name. The 'compound' section may look like
+   this:
+
+   ```
+   compounds:
+     stats_dtype:
+       time: [u8, seconds since 1970-01-01T00:00:00, timestamp]
+       index: [u2, '1', index]
+       tbl_id: [u1, '1', binning id]
+       saa: [u1, '1', saa-flag]
+       coad: [u1, '1', co-addings]
+       texp: [f4, ms, exposure time]
+       lat: [f4, degree, latitude]
+       lon: [f4, degree, longitude]
+       avg: [f4, '1', '$S - S_{ref}$']
+       unc: [f4, '1', '\u03c3($S - S_{ref}$)']
+       dark_offs: [f4, '1', dark-offset]
+   ```
+
+   Alternatively, provide a list with names of YAML files which contain the definitions
+   of the compounds.
+
+   compounds:
+     - h5_nomhk_tm.yaml
+     - h5_science_hk.yaml
+
+ * The 'variables' are defined by their data-type ('_dtype') and dimensions ('_dims'),
+   and optionally chunk sizes ('_chunks'), compression ('_compression'), variable length
+   ('_vlen'). In addition, each variable can have as many attributes as you like,
+   defined by its name and value. The 'variables' section may look like this:
+
+   ```
+   variables:
+     /image_attributes/nr_coadditions:
+       _dtype: u2
+       _dims: [number_of_images]
+       _FillValue: 0
+       long_name: Number of coadditions
+       units: '1'
+       valid_min: 1
+     /image_attributes/exposure_time:
+       _dtype: f8
+       _dims: [number_of_images]
+       _FillValue: -32767
+       long_name: Exposure time
+       units: seconds
+     stats_163:
+       _dtype: stats_dtype
+       _vlen: True
+       _dims: [days]
+       comment: detector map statistics (MPS=163)
+   ```
+
+### Notes and ToDo:
+
+ * The usage of older versions of h5py may result in broken netCDF4 files
+ * Explain usage of parameter '_chunks', which is currently not correcly implemented.
+ * Explain that the usage of variable length data-sets may break netCDF4 compatibility
+
+## Support [TBW]
+
+## Roadmap
+
+ * Release v0.1 : stable API to read your YAML files and generate the HDF5/netCDF4 file
+
+
+## Authors and acknowledgment
+The code is developed by R.M. van Hees (SRON)
+
+## License
+
+* Copyright: SRON (https://www.sron.nl).
+* License: BSD-3-clause
+
+## Project status
+Beta

h5yaml-0.0.3.dist-info/RECORD

@@ -0,0 +1,9 @@
+h5yaml/conf_from_yaml.py,sha256=FT5oS4yqDFUYZqgria_OrmMK52ZcrTVoAPyPkLrHstc,982
+h5yaml/yaml_h5py.py,sha256=m5vOdVour3FwnUjewGukIra6C_c0F61yqnsvUJN-KtM,8591
+h5yaml/yaml_nc.py,sha256=KG2y497If2tJmSSmF6bvXl7ePKorptEUEJULPexBIQw,7980
+h5yaml/Data/h5_testing.yaml,sha256=_x3qBC8RNQ1h4c6B1JOH_y0L9DiDLsOEfyr60IcvpoI,2358
+h5yaml/lib/chunksizes.py,sha256=aOXkLqTk5GgE-uk80QqHYbLB-FzBMnOrMm6ixH4QAUc,1225
+h5yaml-0.0.3.dist-info/METADATA,sha256=CQm7-Uxop-K7v5-WotW6DiKFPtYJXwEi9OJfJKC0o7I,5370
+h5yaml-0.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+h5yaml-0.0.3.dist-info/licenses/LICENSE,sha256=MoOwtPnC77nFaIwRIAIE6fKhrzMd3G18mOXDPtAH8G0,1509
+h5yaml-0.0.3.dist-info/RECORD,,

h5yaml-0.0.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

h5yaml-0.0.3.dist-info/licenses/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2019-2025 SRON
+  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.