h5yaml 0.1.1__py3-none-any.whl → 0.2.1__py3-none-any.whl

h5yaml/yaml_h5.py

@@ -1,11 +1,22 @@
 #
-# This file is part of h5_yaml
-#    https://github.com/rmvanhees/h5_yaml.git
+# This file is part of Python package: `h5yaml`
 #
-# Copyright (c) 2025 SRON
-#    All Rights Reserved
+#     https://github.com/rmvanhees/pyxarr.git
 #
-# License:  BSD-3-Clause
+# Copyright (c) 2025 - R.M. van Hees (SRON)
+#    All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 #
 """Create HDF5/netCDF4 formatted file from a YAML configuration file using h5py."""
 
@@ -14,52 +25,13 @@ 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
-
-
-# - helper function ------------------------------------
-def adjust_attr(attr_key: str, attr_val: np.ndarray, attr_dtype: str) -> np.ndarray:
-    """..."""
-    if attr_key in ("valid_min", "valid_max", "valid_range"):
-        match attr_dtype:
-            case "i1":
-                res = np.int8(attr_val)
-            case "i2":
-                res = np.int16(attr_val)
-            case "i4":
-                res = np.int32(attr_val)
-            case "i8":
-                res = np.int64(attr_val)
-            case "u1":
-                res = np.uint8(attr_val)
-            case "u2":
-                res = np.uint16(attr_val)
-            case "u4":
-                res = np.uint32(attr_val)
-            case "u8":
-                res = np.uint64(attr_val)
-            case "f2":
-                res = np.float16(attr_val)
-            case "f4":
-                res = np.float32(attr_val)
-            case "f8":
-                res = np.float64(attr_val)
-            case _:
-                res = attr_val
-
-        return res
-
-    if attr_key == "flag_values":
-        return np.array(attr_val, dtype="u1")
-
-    return attr_val
+from .conf_from_yaml import conf_from_yaml
+from .lib.adjust_attr import adjust_attr
 
 
 # - class definition -----------------------------------
@@ -68,12 +40,12 @@ class H5Yaml:
 
     Parameters
     ----------
-    h5_yaml_fl :  Path
-       YAML files with the HDF5 format definition
+    h5_yaml_fl :  Path | str
+       YAML file with the HDF5 format definition
 
     """
 
-    def __init__(self: H5Yaml, h5_yaml_fl: Path) -> None:
+    def __init__(self: H5Yaml, h5_yaml_fl: Path | str) -> None:
         """Construct a H5Yaml instance."""
         self.logger = logging.getLogger("h5yaml.H5Yaml")
 
@@ -99,14 +71,14 @@ class H5Yaml:
                 )
 
             if val["_size"] == 0:
-                ds_chunk = val.get("_chunks", (50,))
+                ds_chunk = val.get("_chunks")
+                if ds_chunk is not None and not isinstance(ds_chunk, bool):
+                    ds_chunk = tuple(ds_chunk)
                 dset = fid.create_dataset(
                     key,
                     shape=(0,),
-                    dtype=(
-                        h5py.string_dtype() if val["_dtype"] == "str" else val["_dtype"]
-                    ),
-                    chunks=ds_chunk if isinstance(ds_chunk, tuple) else tuple(ds_chunk),
+                    dtype="T" if val["_dtype"] == "str" else val["_dtype"],
+                    chunks=ds_chunk,
                     maxshape=(None,),
                     fillvalue=fillvalue,
                 )
@@ -114,7 +86,7 @@ class H5Yaml:
                 dset = fid.create_dataset(
                     key,
                     shape=(val["_size"],),
-                    dtype=val["_dtype"],
+                    dtype="T" if val["_dtype"] == "str" else val["_dtype"],
                 )
                 if "_values" in val:
                     dset[:] = val["_values"]
@@ -128,7 +100,7 @@ class H5Yaml:
             )
             for attr, attr_val in val.items():
                 if not attr.startswith("_"):
-                    dset.attrs[attr] = adjust_attr(attr, attr_val, val["_dtype"])
+                    dset.attrs[attr] = adjust_attr(val["_dtype"], attr, attr_val)
 
     def __compounds(self: H5Yaml, fid: h5py.File) -> dict[str, str | int | float]:
         """Add compound datatypes to HDF5 product."""
@@ -182,10 +154,8 @@ class H5Yaml:
         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
+                ds_dtype = "T" if val["_dtype"] == "str" else val["_dtype"]
 
             fillvalue = None
             if "_FillValue" in val:
@@ -203,7 +173,7 @@ class H5Yaml:
                 )
                 for attr, attr_val in val.items():
                     if not attr.startswith("_"):
-                        dset.attrs[attr] = adjust_attr(attr, attr_val, val["_dtype"])
+                        dset.attrs[attr] = adjust_attr(val["_dtype"], attr, attr_val)
                 continue
 
             n_udim = 0
@@ -217,17 +187,15 @@ class H5Yaml:
 
             # currently, we can not handle more than one unlimited dimension
             if n_udim > 1:
-                raise ValueError("more than one unlimited dimension")
+                raise ValueError(f"{key} has more than one unlimited dimension")
 
-            # obtain chunk-size settings
-            ds_chunk = (
-                val["_chunks"]
-                if "_chunks" in val
-                else guess_chunks(ds_shape, dtype_size)
-            )
+            if None in ds_maxshape and val.get("_chunks") == "contiguous":
+                raise KeyError(
+                    "you can not create a contiguous dataset with unlimited dimensions."
+                )
 
             # create the variable
-            if ds_chunk == "contiguous":
+            if val.get("_chunks") == "contiguous":
                 dset = fid.create_dataset(
                     key,
                     ds_shape,
@@ -237,6 +205,9 @@ class H5Yaml:
                     fillvalue=fillvalue,
                 )
             else:
+                ds_chunk = val.get("_chunks")
+                if ds_chunk is not None and not isinstance(ds_chunk, bool):
+                    ds_chunk = tuple(ds_chunk)
                 compression = None
                 shuffle = False
                 # currently only gzip compression is supported
@@ -254,14 +225,12 @@ class H5Yaml:
                         fid[ds_name] = h5py.vlen_dtype(ds_dtype)
                     ds_dtype = fid[ds_name]
                     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),
+                    chunks=ds_chunk,
                     maxshape=ds_maxshape,
                     fillvalue=fillvalue,
                     compression=compression,
@@ -273,7 +242,7 @@ class H5Yaml:
 
             for attr, attr_val in val.items():
                 if not attr.startswith("_"):
-                    dset.attrs[attr] = adjust_attr(attr, attr_val, val["_dtype"])
+                    dset.attrs[attr] = adjust_attr(val["_dtype"], attr, attr_val)
 
             if compounds is not None and val["_dtype"] in compounds:
                 if compounds[val["_dtype"]]["units"]:
@@ -286,6 +255,15 @@ class H5Yaml:
         """Return definition of the HDF5/netCDF4 product."""
         return self._h5_def
 
+    def diskless(self: H5Yaml) -> h5py.File:
+        """Create a HDF5/netCDF4 file in memory."""
+        fid = h5py.File.in_memory()
+        if "groups" in self.h5_def:
+            self.__groups(fid)
+        self.__dimensions(fid)
+        self.__variables(fid, self.__compounds(fid))
+        return fid
+
     def create(self: H5Yaml, l1a_name: Path | str) -> None:
         """Create a HDF5/netCDF4 file (overwrite if exist).
 
@@ -303,14 +281,3 @@ class H5Yaml:
                 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

@@ -1,11 +1,22 @@
 #
-# This file is part of h5_yaml:
-#    https://github.com/rmvanhees/h5_yaml.git
+# This file is part of Python package: `h5yaml`
 #
-# Copyright (c) 2025 SRON
-#    All Rights Reserved
+#     https://github.com/rmvanhees/pyxarr.git
 #
-# License:  BSD-3-Clause
+# Copyright (c) 2025 - R.M. van Hees (SRON)
+#    All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 #
 """Create HDF5/netCDF4 formatted file from a YAML configuration file using netCDF4."""
 
@@ -14,7 +25,6 @@ from __future__ import annotations
 __all__ = ["NcYaml"]
 
 import logging
-from importlib.resources import files
 from pathlib import PurePosixPath
 from typing import TYPE_CHECKING
 
@@ -23,8 +33,8 @@ 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
+from .conf_from_yaml import conf_from_yaml
+from .lib.adjust_attr import adjust_attr
 
 if TYPE_CHECKING:
     from pathlib import Path
@@ -32,22 +42,29 @@ if TYPE_CHECKING:
 
 # - class definition -----------------------------------
 class NcYaml:
-    """Class to create a HDF5/netCDF4 formated file from a YAML configuration file."""
+    """Class to create a HDF5/netCDF4 formated file from a YAML configuration file.
+
+    Parameters
+    ----------
+    nc_yaml_fl :  Path | str
+       YAML file with the netCDF4 format definition
+
+    """
 
-    def __init__(self: NcYaml, h5_yaml_fl: Path) -> None:
+    def __init__(self: NcYaml, nc_yaml_fl: Path | str) -> None:
         """Construct a NcYaml instance."""
         self.logger = logging.getLogger("h5yaml.NcYaml")
 
         try:
-            self._h5_def = conf_from_yaml(h5_yaml_fl)
+            self._nc_def = conf_from_yaml(nc_yaml_fl)
         except RuntimeError as exc:
             raise RuntimeError from exc
 
-        self.yaml_dir = h5_yaml_fl.parent
+        self.yaml_dir = nc_yaml_fl.parent
 
     def __groups(self: NcYaml, fid: Dataset) -> None:
         """Create groups in HDF5 product."""
-        for key in self.h5_def["groups"]:
+        for key in self.nc_def["groups"]:
             pkey = PurePosixPath(key)
             if pkey.is_absolute():
                 _ = fid[pkey.parent].createGroup(pkey.name)
@@ -56,14 +73,14 @@ class NcYaml:
 
     def __dimensions(self: NcYaml, fid: Dataset) -> None:
         """Add dimensions to HDF5 product."""
-        for key, value in self.h5_def["dimensions"].items():
+        for key, value in self.nc_def["dimensions"].items():
             pkey = PurePosixPath(key)
             if pkey.is_absolute():
                 _ = fid[pkey.parent].createDimension(pkey.name, value["_size"])
             else:
                 _ = fid.createDimension(key, value["_size"])
 
-            if "long_name" not in value:
+            if len(value) <= 2:
                 continue
 
             fillvalue = None
@@ -88,17 +105,29 @@ class NcYaml:
                     fill_value=fillvalue,
                     contiguous=value["_size"] != 0,
                 )
-            dset.setncatts({k: v for k, v in value.items() if not k.startswith("_")})
+            if value["_size"] > 0:
+                if "_values" in value:
+                    dset[:] = np.array(value["_values"])
+                elif "_range" in value:
+                    dset[:] = np.arange(*value["_range"], dtype=value["_dtype"])
+
+            dset.setncatts(
+                {
+                    k: adjust_attr(value["_dtype"], 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:
+        if "compounds" not in self.nc_def:
             return {}
 
         compounds = {}
-        if isinstance(self.h5_def["compounds"], list):
-            file_list = self.h5_def["compounds"].copy()
-            self.h5_def["compounds"] = {}
+        if isinstance(self.nc_def["compounds"], list):
+            file_list = self.nc_def["compounds"].copy()
+            self.nc_def["compounds"] = {}
             for name in file_list:
                 if not (yaml_fl := self.yaml_dir / name).is_file():
                     continue
@@ -107,9 +136,9 @@ class NcYaml:
                 except RuntimeError as exc:
                     raise RuntimeError from exc
                 for key, value in res.items():
-                    self.h5_def["compounds"][key] = value
+                    self.nc_def["compounds"][key] = value
 
-        for key, value in self.h5_def["compounds"].items():
+        for key, value in self.nc_def["compounds"].items():
             compounds[key] = {
                 "dtype": [],
                 "units": [],
@@ -142,13 +171,15 @@ class NcYaml:
            Definition of the compound(s) in the product
 
         """
-        for key, val in self.h5_def["variables"].items():
+        for key, val in self.nc_def["variables"].items():
+            pkey = PurePosixPath(key)
+            var_grp = fid[pkey.parent] if pkey.is_absolute() else fid
+            var_name = pkey.name if pkey.is_absolute() else key
+
             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:
@@ -156,6 +187,23 @@ class NcYaml:
                     np.nan if val["_FillValue"] == "NaN" else int(val["_FillValue"])
                 )
 
+            # check for scalar dataset
+            if val["_dims"][0] == "scalar":
+                dset = var_grp.createVariable(
+                    var_name,
+                    val["_dtype"],
+                    fill_value=fillvalue,
+                    contiguous=True,
+                )
+                dset.setncatts(
+                    {
+                        k: adjust_attr(val["_dtype"], k, v)
+                        for k, v in val.items()
+                        if not k.startswith("_")
+                    }
+                )
+                continue
+
             compression = None
             complevel = 0
             # currently only gzip compression is supported
@@ -182,19 +230,16 @@ class NcYaml:
             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)
-            )
+            if None in ds_maxshape and val.get("_chunks") == "contiguous":
+                raise KeyError(
+                    "you can not create a contiguous dataset with unlimited dimensions."
+                )
 
-            pkey = PurePosixPath(key)
-            var_grp = fid[pkey.parent] if pkey.is_absolute() else fid
-            var_name = pkey.name if pkey.is_absolute() else key
             if val["_dtype"] in fid.cmptypes:
                 val["_dtype"] = fid.cmptypes[val["_dtype"]]
 
             # create the variable
-            if ds_chunk == "contiguous":
+            if val.get("_chunks") == "contiguous":
                 dset = var_grp.createVariable(
                     var_name,
                     val["_dtype"],
@@ -203,27 +248,32 @@ class NcYaml:
                     contiguous=True,
                 )
             else:
+                ds_chunk = val.get("_chunks")
+                if ds_chunk is not None and not isinstance(ds_chunk, bool):
+                    ds_chunk = tuple(ds_chunk)
                 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,)
 
                 dset = var_grp.createVariable(
                     var_name,
-                    val["_dtype"],
+                    str if val["_dtype"] == "str" else val["_dtype"],
                     dimensions=var_dims,
                     fill_value=fillvalue,
-                    contiguous=False,
                     compression=compression,
                     complevel=complevel,
-                    chunksizes=(
-                        ds_chunk if isinstance(ds_chunk, tuple) else tuple(ds_chunk)
-                    ),
+                    chunksizes=ds_chunk,
+                    contiguous=False,
                 )
-            dset.setncatts({k: v for k, v in val.items() if not k.startswith("_")})
+            dset.setncatts(
+                {
+                    k: adjust_attr(val["_dtype"], 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"]:
@@ -232,9 +282,17 @@ class NcYaml:
                     dset.attrs["long_name"] = compounds[val["_dtype"]]["names"]
 
     @property
-    def h5_def(self: NcYaml) -> dict:
+    def nc_def(self: NcYaml) -> dict:
         """Return definition of the HDF5/netCDF4 product."""
-        return self._h5_def
+        return self._nc_def
+
+    def diskless(self: NcYaml) -> Dataset:
+        """Create a HDF5/netCDF4 file in memory."""
+        fid = Dataset("diskless_test.nc", "w", diskless=True, persistent=False)
+        self.__groups(fid)
+        self.__dimensions(fid)
+        self.__variables(fid, self.__compounds(fid))
+        return fid
 
     def create(self: NcYaml, l1a_name: Path | str) -> None:
         """Create a HDF5/netCDF4 file (overwrite if exist).
@@ -251,15 +309,4 @@ class NcYaml:
                 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") / "nc_testing.yaml").create("test_yaml.nc")
-
-
-if __name__ == "__main__":
-    tests()
+            raise RuntimeError(f"failed to create {l1a_name}") from exc

{h5yaml-0.1.1.dist-info → h5yaml-0.2.1.dist-info}/METADATA

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: h5yaml
-Version: 0.1.1
+Version: 0.2.1
 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-Expression: Apache-2.0
 License-File: LICENSE
-Keywords: HDF5,YAML,netCDF4
+Keywords: CF metadata,HDF5,YAML,netCDF4
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -19,12 +19,15 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
 Requires-Python: >=3.10
-Requires-Dist: h5py>=3.11
+Requires-Dist: h5py>=3.14
 Requires-Dist: netcdf4>=1.7
-Requires-Dist: numpy>=1.26.4
+Requires-Dist: numpy>=2.0
 Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=9.0; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest-cov>=7.0; extra == 'test'
 Description-Content-Type: text/markdown
 
 # H5YAML
@@ -58,7 +61,19 @@ However, package `netCDF4` has some limitations, which `h5py` has not, for examp
 not allow variable-length variables to have a compound data-type.
 
 ## Installation
-Releases of the code, starting from version 0.1, will be made available via PyPI.
+The package `h5yaml` is available from PyPI. To install it use `pip`:
+
+> $ pip install [--user] h5yaml
+
+The module `h5yaml` requires Python3.10+ and Python modules: h5py (v3.14+), netCDF4 (v1.7+) and numpy (v2.0+).
+
+**Note**: the packages `h5py` and `netCDF4` come with their own HDF5 libraries. If these are different then they may
+collide and result in a *''HDF5 error''*.
+If this is the case then you have to install the development packages of HDF5 and netCDF4 (or compile them from source).
+And reinstall `h5py` and `netCDF4` using the commands:
+
+> $ pip uninstall h5py; pip install --no-binary=h5py h5py
+> $ pip uninstall netCDF4; pip install --no-binary=netCDF4 netCDF4
 
 ## Usage
 
@@ -173,7 +188,7 @@ The YAML file should be structured as follows:
 
 ## Support [TBW]
 
-## Roadmap
+## Road map
 
  * Release v0.1 : stable API to read your YAML files and generate the HDF5/netCDF4 file
 
@@ -183,5 +198,5 @@ The code is developed by R.M. van Hees (SRON)
 
 ## License
 
-* Copyright: SRON (https://www.sron.nl).
-* License: BSD-3-clause
+* Copyright: Richard van Hees (SRON) (https://www.sron.nl).
+* License: Apache-2.0

h5yaml-0.2.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+h5yaml/__init__.py,sha256=NdNciPgYnbq-aVM6QqNGNZtdL72rTGLAMrDy0Yw7ckk,751
+h5yaml/conf_from_yaml.py,sha256=GVbWR-I0_sKRxrXmgLxbnTJvAXz5OtFtNYu4Pp3LaaI,1607
+h5yaml/yaml_h5.py,sha256=K9KkdHNDadrrwlR5EJWuzf1yFZcycJLm3EaiM4nLHkw,10112
+h5yaml/yaml_nc.py,sha256=0xJ0dYnIXEhUVZGEkv9GZZu4Xo7K4zXPGiG49j8RHKs,10977
+h5yaml/Data/h5_compound.yaml,sha256=z3dMCJDRAw14boRp0zT74bz_oFi21yu8coUoKOW-d2Q,1131
+h5yaml/Data/h5_testing.yaml,sha256=BSrjenq_L5g8GGoldtU_NbWzLSymwAcvFOh26jtoynM,6247
+h5yaml/Data/h5_unsupported.yaml,sha256=v4HYhiTikFt6UoEUJBnmSse_WeHbmBgqF2e1bCJEfLw,1502
+h5yaml/Data/nc_testing.yaml,sha256=zKDRkYpWVM3_vDpsu-ZxHAGDlITICb_nwjDKsFzPgcQ,5807
+h5yaml/lib/__init__.py,sha256=NdNciPgYnbq-aVM6QqNGNZtdL72rTGLAMrDy0Yw7ckk,751
+h5yaml/lib/adjust_attr.py,sha256=4dHEGwwIa3a3hihyuSX8jCsC08fYcz_9XWA1pBwiwfc,2284
+h5yaml-0.2.1.dist-info/METADATA,sha256=Z-be-4WMz4o1RY4WiY3o-pnfEq72cdvTkDnmTQUnaJY,7876
+h5yaml-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+h5yaml-0.2.1.dist-info/licenses/LICENSE,sha256=rLarIZOYK5jHuUjMnFbgdI_Tb_4_HAAKSOOIhwiWlE4,11356
+h5yaml-0.2.1.dist-info/RECORD,,