rashdf 0.5.0__tar.gz → 0.7.0__tar.gz

{rashdf-0.5.0 → rashdf-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rashdf
-Version: 0.5.0
+Version: 0.7.0
 Summary: Read data from HEC-RAS HDF files.
 Project-URL: repository, https://github.com/fema-ffrd/rashdf
 Classifier: Development Status :: 4 - Beta
@@ -22,7 +22,12 @@ Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: fiona; extra == "dev"
+Requires-Dist: kerchunk; extra == "dev"
+Requires-Dist: zarr; extra == "dev"
+Requires-Dist: dask; extra == "dev"
+Requires-Dist: fsspec; extra == "dev"
+Requires-Dist: s3fs; extra == "dev"
+Requires-Dist: fiona==1.9.6; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: numpydoc; extra == "docs"
@@ -140,8 +145,12 @@ $ python -m venv venv-rashdf
 
 Activate the virtual environment:
 ```
-$ source ./venv/bin/activate
+# For macOS/Linux
+$ source ./venv-rashdf/bin/activate
 (venv-rashdf) $
+
+# For Windows
+> ./venv-rashdf/Scripts/activate
 ```
 
 Install dev dependencies:

{rashdf-0.5.0 → rashdf-0.7.0}/README.md

@@ -110,8 +110,12 @@ $ python -m venv venv-rashdf
 
 Activate the virtual environment:
 ```
-$ source ./venv/bin/activate
+# For macOS/Linux
+$ source ./venv-rashdf/bin/activate
 (venv-rashdf) $
+
+# For Windows
+> ./venv-rashdf/Scripts/activate
 ```
 
 Install dev dependencies:

{rashdf-0.5.0 → rashdf-0.7.0}/pyproject.toml

@@ -12,11 +12,11 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
 ]
-version = "0.5.0"
+version = "0.7.0"
 dependencies = ["h5py", "geopandas>=1.0,<2.0", "pyarrow", "xarray"]
 
 [project.optional-dependencies]
-dev = ["pre-commit", "ruff", "pytest", "pytest-cov", "fiona"]
+dev = ["pre-commit", "ruff", "pytest", "pytest-cov", "kerchunk", "zarr", "dask", "fsspec", "s3fs", "fiona==1.9.6"]
 docs = ["sphinx", "numpydoc", "sphinx_rtd_theme"]
 
 [project.urls]

{rashdf-0.5.0 → rashdf-0.7.0}/src/rashdf/base.py

@@ -19,6 +19,7 @@ class RasHdf(h5py.File):
             Additional keyword arguments to pass to h5py.File
         """
         super().__init__(name, mode="r", **kwargs)
+        self._loc = name
 
     @classmethod
     def open_uri(
@@ -49,7 +50,9 @@ class RasHdf(h5py.File):
         import fsspec
 
         remote_file = fsspec.open(uri, mode="rb", **fsspec_kwargs)
-        return cls(remote_file.open(), **h5py_kwargs)
+        result = cls(remote_file.open(), **h5py_kwargs)
+        result._loc = uri
+        return result
 
     def get_attrs(self, attr_path: str) -> Dict:
         """Convert attributes from a HEC-RAS HDF file into a Python dictionary for a given attribute path.

{rashdf-0.5.0 → rashdf-0.7.0}/src/rashdf/plan.py

@@ -5,6 +5,8 @@ from .utils import (
     df_datetimes_to_str,
     ras_timesteps_to_datetimes,
     parse_ras_datetime_ms,
+    deprecated,
+    convert_ras_hdf_value,
 )
 
 from geopandas import GeoDataFrame
@@ -155,6 +157,7 @@ class RasPlanHdf(RasGeomHdf):
     PLAN_INFO_PATH = "Plan Data/Plan Information"
     PLAN_PARAMS_PATH = "Plan Data/Plan Parameters"
     PRECIP_PATH = "Event Conditions/Meteorology/Precipitation"
+    OBS_DATA_PATH = "Event Conditions/Observed Data"
     RESULTS_UNSTEADY_PATH = "Results/Unsteady"
     RESULTS_UNSTEADY_SUMMARY_PATH = f"{RESULTS_UNSTEADY_PATH}/Summary"
     VOLUME_ACCOUNTING_PATH = f"{RESULTS_UNSTEADY_PATH}/Volume Accounting"
@@ -165,6 +168,8 @@ class RasPlanHdf(RasGeomHdf):
     UNSTEADY_TIME_SERIES_PATH = f"{BASE_OUTPUT_PATH}/Unsteady Time Series"
     REFERENCE_LINES_OUTPUT_PATH = f"{UNSTEADY_TIME_SERIES_PATH}/Reference Lines"
     REFERENCE_POINTS_OUTPUT_PATH = f"{UNSTEADY_TIME_SERIES_PATH}/Reference Points"
+    OBS_FLOW_OUTPUT_PATH = f"{OBS_DATA_PATH}/Flow"
+    OBS_STAGE_OUTPUT_PATH = f"{OBS_DATA_PATH}/Stage"
 
     RESULTS_STEADY_PATH = "Results/Steady"
     BASE_STEADY_PATH = f"{RESULTS_STEADY_PATH}/Output/Output Blocks/Base Output"
@@ -585,7 +590,8 @@ class RasPlanHdf(RasGeomHdf):
         Returns
         -------
         DataFrame
-            A DataFrame with columns 'mesh_name', 'cell_id' or 'face_id', a value column, and a time column.
+            A DataFrame with columns 'mesh_name', 'cell_id' or 'face_id', a value column,
+            and a time column if the value corresponds to a specific time.
         """
         methods_with_times = {
             SummaryOutputVar.MAXIMUM_WATER_SURFACE: self.mesh_max_ws,
@@ -604,6 +610,76 @@ class RasPlanHdf(RasGeomHdf):
             df = other_methods[var]()
         return df
 
+    def _mesh_summary_outputs_df(
+        self,
+        cells_or_faces: str,
+        output_vars: Optional[List[SummaryOutputVar]] = None,
+        round_to: str = "0.1 s",
+    ) -> DataFrame:
+        if cells_or_faces == "cells":
+            feature_id_field = "cell_id"
+        elif cells_or_faces == "faces":
+            feature_id_field = "face_id"
+        else:
+            raise ValueError('cells_or_faces must be either "cells" or "faces".')
+        if output_vars is None:
+            summary_output_vars = self._summary_output_vars(
+                cells_or_faces=cells_or_faces
+            )
+        elif isinstance(output_vars, list):
+            summary_output_vars = []
+            for var in output_vars:
+                if not isinstance(var, SummaryOutputVar):
+                    var = SummaryOutputVar(var)
+                summary_output_vars.append(var)
+        else:
+            raise ValueError(
+                "include_output must be a boolean or a list of SummaryOutputVar values."
+            )
+        df = self.mesh_summary_output(summary_output_vars[0], round_to=round_to)
+        for var in summary_output_vars[1:]:
+            df_var = self.mesh_summary_output(var, round_to=round_to)
+            df = df.merge(df_var, on=["mesh_name", feature_id_field], how="left")
+        return df
+
+    def mesh_cells_summary_output(self, round_to: str = "0.1 s") -> DataFrame:
+        """
+        Return a DataFrame with summary output data for each mesh cell in the model.
+
+        Parameters
+        ----------
+        round_to : str, optional
+            The time unit to round the datetimes to. Default: "0.1 s" (seconds).
+            See Pandas documentation for valid time units:
+            https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html
+
+        Returns
+        -------
+        DataFrame
+            A DataFrame with columns 'mesh_name', 'cell_id', and columns for each
+            summary output variable.
+        """
+        return self._mesh_summary_outputs_df("cells", round_to=round_to)
+
+    def mesh_faces_summary_output(self, round_to: str = "0.1 s") -> DataFrame:
+        """
+        Return a DataFrame with summary output data for each mesh face in the model.
+
+        Parameters
+        ----------
+        round_to : str, optional
+            The time unit to round the datetimes to. Default: "0.1 s" (seconds).
+            See Pandas documentation for valid time units:
+            https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html
+
+        Returns
+        -------
+        DataFrame
+            A DataFrame with columns 'mesh_name', 'face_id', and columns for each
+            summary output variable.
+        """
+        return self._mesh_summary_outputs_df("faces", round_to=round_to)
+
     def _summary_output_vars(
         self, cells_or_faces: Optional[str] = None
     ) -> List[SummaryOutputVar]:
@@ -812,7 +888,7 @@ class RasPlanHdf(RasGeomHdf):
         mesh_name: str,
         var: TimeSeriesOutputVar,
     ) -> Tuple[np.ndarray, str]:
-        path = f"{self.UNSTEADY_TIME_SERIES_PATH}/2D Flow Areas/{mesh_name}/{var.value}"
+        path = self._mesh_timeseries_output_path(mesh_name, var.value)
         group = self.get(path)
         try:
             import dask.array as da
@@ -830,6 +906,7 @@ class RasPlanHdf(RasGeomHdf):
         self,
         mesh_name: str,
         var: Union[str, TimeSeriesOutputVar],
+        truncate: bool = True,
     ) -> xr.DataArray:
         """Return the time series output data for a given variable.
 
@@ -839,6 +916,8 @@ class RasPlanHdf(RasGeomHdf):
             The name of the 2D flow area mesh.
         var : TimeSeriesOutputVar
             The time series output variable to retrieve.
+        truncate : bool, optional
+            If True, truncate the number of cells to the listed cell count.
 
         Returns
         -------
@@ -856,7 +935,10 @@ class RasPlanHdf(RasGeomHdf):
         values, units = self._mesh_timeseries_output_values_units(mesh_name, var)
         if var in TIME_SERIES_OUTPUT_VARS_CELLS:
             cell_count = mesh_names_counts[mesh_name]
-            values = values[:, :cell_count]
+            if truncate:
+                values = values[:, :cell_count]
+            else:
+                values = values[:, :]
             id_coord = "cell_id"
         elif var in TIME_SERIES_OUTPUT_VARS_FACES:
             id_coord = "face_id"
@@ -874,24 +956,28 @@ class RasPlanHdf(RasGeomHdf):
                 "mesh_name": mesh_name,
                 "variable": var.value,
                 "units": units,
+                "hdf_path": self._mesh_timeseries_output_path(mesh_name, var.value),
             },
         )
         return da
 
+    def _mesh_timeseries_output_path(self, mesh_name: str, var_name: str) -> str:
+        return f"{self.UNSTEADY_TIME_SERIES_PATH}/2D Flow Areas/{mesh_name}/{var_name}"
+
     def _mesh_timeseries_outputs(
-        self, mesh_name: str, vars: List[TimeSeriesOutputVar]
+        self, mesh_name: str, vars: List[TimeSeriesOutputVar], truncate: bool = True
     ) -> xr.Dataset:
         datasets = {}
         for var in vars:
             var_path = f"{self.UNSTEADY_TIME_SERIES_PATH}/2D Flow Areas/{mesh_name}/{var.value}"
             if self.get(var_path) is None:
                 continue
-            da = self.mesh_timeseries_output(mesh_name, var)
+            da = self.mesh_timeseries_output(mesh_name, var, truncate=truncate)
             datasets[var.value] = da
         ds = xr.Dataset(datasets, attrs={"mesh_name": mesh_name})
         return ds
 
-    def mesh_timeseries_output_cells(self, mesh_name: str) -> xr.Dataset:
+    def mesh_cells_timeseries_output(self, mesh_name: str) -> xr.Dataset:
         """Return the time series output data for cells in a 2D flow area mesh.
 
         Parameters
@@ -907,7 +993,25 @@ class RasPlanHdf(RasGeomHdf):
         ds = self._mesh_timeseries_outputs(mesh_name, TIME_SERIES_OUTPUT_VARS_CELLS)
         return ds
 
-    def mesh_timeseries_output_faces(self, mesh_name: str) -> xr.Dataset:
+    @deprecated
+    def mesh_timeseries_output_cells(self, mesh_name: str) -> xr.Dataset:
+        """Return the time series output data for cells in a 2D flow area mesh.
+
+        Deprecated: use mesh_cells_timeseries_output instead.
+
+        Parameters
+        ----------
+        mesh_name : str
+            The name of the 2D flow area mesh.
+
+        Returns
+        -------
+        xr.Dataset
+            An xarray Dataset with DataArrays for each time series output variable.
+        """
+        return self.mesh_cells_timeseries_output(mesh_name)
+
+    def mesh_faces_timeseries_output(self, mesh_name: str) -> xr.Dataset:
         """Return the time series output data for faces in a 2D flow area mesh.
 
         Parameters
@@ -923,6 +1027,24 @@ class RasPlanHdf(RasGeomHdf):
         ds = self._mesh_timeseries_outputs(mesh_name, TIME_SERIES_OUTPUT_VARS_FACES)
         return ds
 
+    @deprecated
+    def mesh_timeseries_output_faces(self, mesh_name: str) -> xr.Dataset:
+        """Return the time series output data for faces in a 2D flow area mesh.
+
+        Deprecated: use mesh_faces_timeseries_output instead.
+
+        Parameters
+        ----------
+        mesh_name : str
+            The name of the 2D flow area mesh.
+
+        Returns
+        -------
+        xr.Dataset
+            An xarray Dataset with DataArrays for each time series output variable.
+        """
+        return self.mesh_faces_timeseries_output(mesh_name)
+
     def reference_timeseries_output(self, reftype: str = "lines") -> xr.Dataset:
         """Return timeseries output data for reference lines or points from a HEC-RAS HDF plan file.
 
@@ -984,7 +1106,7 @@ class RasPlanHdf(RasGeomHdf):
                     f"{abbrev}_name": (f"{abbrev}_id", names),
                     "mesh_name": (f"{abbrev}_id", mesh_areas),
                 },
-                attrs={"Units": units},
+                attrs={"units": units, "hdf_path": f"{output_path}/{var}"},
             )
             das[var] = da
         return xr.Dataset(das)
@@ -999,6 +1121,74 @@ class RasPlanHdf(RasGeomHdf):
         """
         return self.reference_timeseries_output(reftype="lines")
 
+    def observed_timeseries_input(self, vartype: str = "Flow") -> dict:
+        """Return observed timeseries input data for reference lines and points from a HEC-RAS HDF plan file.
+
+        Parameters
+        ----------
+        vartype : str, optional
+            The type of observed data to retrieve. Must be either "Flow" or "Stage".
+            (default: "Flow")
+
+        Returns
+        -------
+        xr.Dataset
+            An xarray Dataset with observed timeseries input data for both reference lines and reference points.
+        """
+        if vartype == "Flow":
+            output_path = self.OBS_FLOW_OUTPUT_PATH
+        elif vartype == "Stage":
+            output_path = self.OBS_STAGE_OUTPUT_PATH
+        else:
+            raise ValueError('vartype must be either "Flow" or "Stage".')
+
+        observed_group = self.get(output_path)
+        if observed_group is None:
+            raise RasPlanHdfError(
+                f"Could not find HDF group at path '{output_path}'."
+                f" Does the Plan HDF file contain reference {vartype} output data?"
+            )
+        if "Attributes" in observed_group.keys():
+            attr_path = observed_group["Attributes"]
+            attrs_df = pd.DataFrame(attr_path[:]).map(convert_ras_hdf_value)
+
+        das = {}
+        for idx, site in enumerate(observed_group.keys()):
+            if site != "Attributes":
+                # Site Ex: 'Ref Point: Grapevine_Lake_RP'
+                site_path = observed_group[site]
+                site_name = site.split(":")[1][1:]  # Grapevine_Lake_RP
+                ref_type = site.split(":")[0]  # Ref Point
+                if ref_type == "Ref Line":
+                    ref_type = "refln"
+                else:
+                    ref_type = "refpt"
+                df = pd.DataFrame(site_path[:]).map(convert_ras_hdf_value)
+                # rename Date to time
+                df = df.rename(columns={"Date": "time"})
+                # Ensure the Date index is unique
+                df = df.drop_duplicates(subset="time")
+                # Package into an 1D xarray DataArray
+                values = df["Value"].values
+                times = df["time"].values
+                da = xr.DataArray(
+                    values,
+                    name=vartype,
+                    dims=["time"],
+                    coords={
+                        "time": times,
+                    },
+                    attrs={
+                        "hdf_path": f"{output_path}/{site}",
+                    },
+                )
+                # Expand dimensions to add additional coordinates
+                da = da.expand_dims({f"{ref_type}_id": [idx - 1]})
+                da = da.expand_dims({f"{ref_type}_name": [site_name]})
+                das[site_name] = da
+        das = xr.concat([das[site] for site in das.keys()], dim="time")
+        return das
+
     def reference_points_timeseries_output(self) -> xr.Dataset:
         """Return timeseries output data for reference points from a HEC-RAS HDF plan file.
 
@@ -1317,3 +1507,113 @@ class RasPlanHdf(RasGeomHdf):
             A DataFrame containing the velocity inside the cross sections
         """
         return self.steady_profile_xs_output(XsSteadyOutputVar.VELOCITY_TOTAL)
+
+    def _zmeta(self, ds: xr.Dataset) -> Dict:
+        """Given a xarray Dataset, return kerchunk-style zarr reference metadata."""
+        from kerchunk.hdf import SingleHdf5ToZarr
+        import zarr
+        import base64
+
+        encoding = {}
+        chunk_meta = {}
+
+        # Loop through each variable / DataArray in the Dataset
+        for var, da in ds.data_vars.items():
+            # The "hdf_path" attribute is the path within the HDF5 file
+            # that the DataArray was read from. This is attribute is inserted
+            # by rashdf (see "mesh_timeseries_output" method).
+            hdf_ds_path = da.attrs["hdf_path"]
+            hdf_ds = self.get(hdf_ds_path)
+            if hdf_ds is None:
+                # If we don't know where in the HDF5 the data came from, we
+                # have to skip it, because we won't be able to generate the
+                # correct metadata for it.
+                continue
+            # Get the filters and storage info for the HDF5 dataset.
+            # Calling private methods from Kerchunk here because
+            # there's not a nice public API for this part. This is hacky
+            # and a bit risky because these private methods are more likely
+            # to change, but short of reimplementing these functions ourselves
+            # it's the best way to get the metadata we need.
+            # TODO: raise an issue in Kerchunk to expose this functionality?
+            filters = SingleHdf5ToZarr._decode_filters(None, hdf_ds)
+            encoding[var] = {"compressor": None, "filters": filters}
+            storage_info = SingleHdf5ToZarr._storage_info(None, hdf_ds)
+            # Generate chunk metadata for the DataArray
+            for key, value in storage_info.items():
+                chunk_number = ".".join([str(k) for k in key])
+                chunk_key = f"{var}/{chunk_number}"
+                chunk_meta[chunk_key] = [str(self._loc), value["offset"], value["size"]]
+        # "Write" the Dataset to a temporary in-memory zarr store (which
+        # is the same a Python dictionary)
+        zarr_tmp = zarr.MemoryStore()
+        # Use compute=False here because we don't _actually_ want to write
+        # the data to the zarr store, we just want to generate the metadata.
+        ds.to_zarr(zarr_tmp, mode="w", compute=False, encoding=encoding)
+        zarr_meta = {"version": 1, "refs": {}}
+        # Loop through the in-memory Zarr store, decode the data to strings,
+        # and add it to the final metadata dictionary.
+        for key, value in zarr_tmp.items():
+            try:
+                value_str = value.decode("utf-8")
+            except UnicodeDecodeError:
+                value_str = "base64:" + base64.b64encode(value).decode("utf-8")
+            zarr_meta["refs"][key] = value_str
+        zarr_meta["refs"].update(chunk_meta)
+        return zarr_meta
+
+    def zmeta_mesh_cells_timeseries_output(self, mesh_name: str) -> Dict:
+        """Return kerchunk-style zarr reference metadata.
+
+        Requires the 'zarr' and 'kerchunk' packages.
+
+        Returns
+        -------
+        dict
+            Dictionary of kerchunk-style zarr reference metadata.
+        """
+        ds = self._mesh_timeseries_outputs(
+            mesh_name, TIME_SERIES_OUTPUT_VARS_CELLS, truncate=False
+        )
+        return self._zmeta(ds)
+
+    def zmeta_mesh_faces_timeseries_output(self, mesh_name: str) -> Dict:
+        """Return kerchunk-style zarr reference metadata.
+
+        Requires the 'zarr' and 'kerchunk' packages.
+
+        Returns
+        -------
+        dict
+            Dictionary of kerchunk-style zarr reference metadata.
+        """
+        ds = self._mesh_timeseries_outputs(
+            mesh_name, TIME_SERIES_OUTPUT_VARS_FACES, truncate=False
+        )
+        return self._zmeta(ds)
+
+    def zmeta_reference_lines_timeseries_output(self) -> Dict:
+        """Return kerchunk-style zarr reference metadata.
+
+        Requires the 'zarr' and 'kerchunk' packages.
+
+        Returns
+        -------
+        dict
+            Dictionary of kerchunk-style zarr reference metadata.
+        """
+        ds = self.reference_lines_timeseries_output()
+        return self._zmeta(ds)
+
+    def zmeta_reference_points_timeseries_output(self) -> Dict:
+        """Return kerchunk-style zarr reference metadata.
+
+        Requires the 'zarr' and 'kerchunk' packages.
+
+        Returns
+        -------
+        dict
+            Dictionary of kerchunk-style zarr reference metadata.
+        """
+        ds = self.reference_points_timeseries_output()
+        return self._zmeta(ds)

{rashdf-0.5.0 → rashdf-0.7.0}/src/rashdf/utils.py

@@ -6,8 +6,8 @@ import pandas as pd
 
 from datetime import datetime, timedelta
 import re
-from typing import Any, List, Tuple, Union, Optional
-from shapely import LineString, Polygon, polygonize_full
+from typing import Any, Callable, List, Tuple, Union, Optional
+import warnings
 
 
 def parse_ras_datetime_ms(datetime_str: str) -> datetime:
@@ -308,3 +308,33 @@ def ras_timesteps_to_datetimes(
         start_time + pd.Timedelta(timestep, unit=time_unit).round(round_to)
         for timestep in timesteps.astype(np.float64)
     ]
+
+
+def deprecated(func) -> Callable:
+    """
+    Deprecate a function.
+
+    This is a decorator which can be used to mark functions as deprecated.
+    It will result in a warning being emitted when the function is used.
+
+    Parameters
+    ----------
+        func: The function to be deprecated.
+
+    Returns
+    -------
+        The decorated function.
+    """
+
+    def new_func(*args, **kwargs):
+        warnings.warn(
+            f"{func.__name__} is deprecated and will be removed in a future version.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        return func(*args, **kwargs)
+
+    new_func.__name__ = func.__name__
+    new_func.__doc__ = func.__doc__
+    new_func.__dict__.update(func.__dict__)
+    return new_func

{rashdf-0.5.0 → rashdf-0.7.0}/src/rashdf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rashdf
-Version: 0.5.0
+Version: 0.7.0
 Summary: Read data from HEC-RAS HDF files.
 Project-URL: repository, https://github.com/fema-ffrd/rashdf
 Classifier: Development Status :: 4 - Beta
@@ -22,7 +22,12 @@ Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: fiona; extra == "dev"
+Requires-Dist: kerchunk; extra == "dev"
+Requires-Dist: zarr; extra == "dev"
+Requires-Dist: dask; extra == "dev"
+Requires-Dist: fsspec; extra == "dev"
+Requires-Dist: s3fs; extra == "dev"
+Requires-Dist: fiona==1.9.6; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: numpydoc; extra == "docs"
@@ -140,8 +145,12 @@ $ python -m venv venv-rashdf
 
 Activate the virtual environment:
 ```
-$ source ./venv/bin/activate
+# For macOS/Linux
+$ source ./venv-rashdf/bin/activate
 (venv-rashdf) $
+
+# For Windows
+> ./venv-rashdf/Scripts/activate
 ```
 
 Install dev dependencies:

{rashdf-0.5.0 → rashdf-0.7.0}/src/rashdf.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ src/rashdf.egg-info/dependency_links.txt
 src/rashdf.egg-info/entry_points.txt
 src/rashdf.egg-info/requires.txt
 src/rashdf.egg-info/top_level.txt
+tests/test_base.py
 tests/test_cli.py
 tests/test_geom.py
 tests/test_plan.py

{rashdf-0.5.0 → rashdf-0.7.0}/src/rashdf.egg-info/requires.txt

@@ -8,7 +8,12 @@ pre-commit
 ruff
 pytest
 pytest-cov
-fiona
+kerchunk
+zarr
+dask
+fsspec
+s3fs
+fiona==1.9.6
 
 [docs]
 sphinx

rashdf-0.7.0/tests/test_base.py

@@ -0,0 +1,20 @@
+from src.rashdf.base import RasHdf
+from unittest.mock import patch
+
+
+def test_open():
+    rasfile = "Muncie.g05.hdf"
+    rasfile_path = f"./tests/data/ras/{rasfile}"
+    hdf = RasHdf(rasfile_path)
+    assert hdf._loc == rasfile_path
+
+
+def test_open_uri():
+    rasfile = "Muncie.g05.hdf"
+    rasfile_path = f"./tests/data/ras/{rasfile}"
+    url = f"s3://mybucket/{rasfile}"
+
+    # Mock the specific functions used by s3fs
+    with patch("s3fs.core.S3FileSystem.open", return_value=open(rasfile_path, "rb")):
+        hdf = RasHdf.open_uri(url)
+        assert hdf._loc == url

{rashdf-0.5.0 → rashdf-0.7.0}/tests/test_plan.py

@@ -5,12 +5,15 @@ from src.rashdf.plan import (
     TimeSeriesOutputVar,
 )
 
+import filecmp
+import json
 from pathlib import Path
 
 import numpy as np
 import pandas as pd
 from pandas.testing import assert_frame_equal
 import pytest
+import xarray as xr
 
 from . import (
     _create_hdf_with_group_attrs,
@@ -26,6 +29,7 @@ TEST_ATTRS = {"test_attribute1": "test_str1", "test_attribute2": 500}
 BALD_EAGLE_P18 = TEST_DATA / "ras/BaldEagleDamBrk.p18.hdf"
 BALD_EAGLE_P18_TIMESERIES = TEST_DATA / "ras/BaldEagleDamBrk.p18.timeseries.hdf"
 BALD_EAGLE_P18_REF = TEST_DATA / "ras/BaldEagleDamBrk.reflines-refpts.p18.hdf"
+DENTON = TEST_DATA / "ras/Denton.hdf"
 MUNCIE_G05 = TEST_DATA / "ras/Muncie.g05.hdf"
 COAL_G01 = TEST_DATA / "ras/Coal.g01.hdf"
 BAXTER_P01 = TEST_DATA / "ras_1d/Baxter.p01.hdf"
@@ -193,9 +197,9 @@ def test_mesh_timeseries_output():
             plan_hdf.mesh_timeseries_output("BaldEagleCr", "Fake Variable")
 
 
-def test_mesh_timeseries_output_cells():
+def test_mesh_cells_timeseries_output():
     with RasPlanHdf(BALD_EAGLE_P18_TIMESERIES) as plan_hdf:
-        ds = plan_hdf.mesh_timeseries_output_cells("BaldEagleCr")
+        ds = plan_hdf.mesh_cells_timeseries_output("BaldEagleCr")
         assert "time" in ds.coords
         assert "cell_id" in ds.coords
         assert "Water Surface" in ds.variables
@@ -212,7 +216,7 @@ def test_mesh_timeseries_output_cells():
         )
         assert_frame_equal(df, valid_df)
 
-        ds = plan_hdf.mesh_timeseries_output_cells("Upper 2D Area")
+        ds = plan_hdf.mesh_cells_timeseries_output("Upper 2D Area")
         assert "time" in ds.coords
         assert "cell_id" in ds.coords
         assert "Water Surface" in ds.variables
@@ -230,9 +234,15 @@ def test_mesh_timeseries_output_cells():
         assert_frame_equal(df, valid_df)
 
 
-def test_mesh_timeseries_output_faces():
+def test_mesh_timeseries_output_cells():
+    with pytest.warns(DeprecationWarning):
+        with RasPlanHdf(BALD_EAGLE_P18_TIMESERIES) as plan_hdf:
+            plan_hdf.mesh_timeseries_output_cells("BaldEagleCr")
+
+
+def test_mesh_faces_timeseries_output():
     with RasPlanHdf(BALD_EAGLE_P18_TIMESERIES) as plan_hdf:
-        ds = plan_hdf.mesh_timeseries_output_faces("BaldEagleCr")
+        ds = plan_hdf.mesh_faces_timeseries_output("BaldEagleCr")
         assert "time" in ds.coords
         assert "face_id" in ds.coords
         assert "Face Velocity" in ds.variables
@@ -249,7 +259,7 @@ def test_mesh_timeseries_output_faces():
         )
         assert_frame_equal(df, valid_df)
 
-        ds = plan_hdf.mesh_timeseries_output_faces("Upper 2D Area")
+        ds = plan_hdf.mesh_faces_timeseries_output("Upper 2D Area")
         assert "time" in ds.coords
         assert "face_id" in ds.coords
         assert "Face Velocity" in ds.variables
@@ -267,6 +277,12 @@ def test_mesh_timeseries_output_faces():
         assert_frame_equal(df, valid_df)
 
 
+def test_mesh_timeseries_output_faces():
+    with pytest.warns(DeprecationWarning):
+        with RasPlanHdf(BALD_EAGLE_P18_TIMESERIES) as plan_hdf:
+            plan_hdf.mesh_timeseries_output_faces("BaldEagleCr")
+
+
 def test_reference_lines(tmp_path: Path):
     plan_hdf = RasPlanHdf(BALD_EAGLE_P18_REF)
     gdf = plan_hdf.reference_lines(datetime_to_str=True)
@@ -291,10 +307,10 @@ def test_reference_lines_timeseries(tmp_path: Path):
 
     ws = ds["Water Surface"]
     assert ws.shape == (37, 4)
-    assert ws.attrs["Units"] == "ft"
+    assert ws.attrs["units"] == "ft"
     q = ds["Flow"]
     assert q.shape == (37, 4)
-    assert q.attrs["Units"] == "cfs"
+    assert q.attrs["units"] == "cfs"
 
     df = ds.sel(refln_id=2).to_dataframe()
     valid_df = pd.read_csv(
@@ -330,9 +346,9 @@ def test_reference_points_timeseries():
 
     ws = ds["Water Surface"]
     assert ws.shape == (37, 3)
-    assert ws.attrs["Units"] == "ft"
+    assert ws.attrs["units"] == "ft"
     v = ds["Velocity"]
-    assert v.attrs["Units"] == "ft/s"
+    assert v.attrs["units"] == "ft/s"
     assert v.shape == (37, 3)
 
     df = ds.sel(refpt_id=1).to_dataframe()
@@ -431,3 +447,206 @@ def test_cross_sections_energy_grade():
         assert _gdf_matches_json_alt(
             phdf.cross_sections_energy_grade(), xs_energy_grade_json
         )
+
+
+def _compare_json(json_file1, json_file2) -> bool:
+    with open(json_file1) as j1:
+        with open(json_file2) as j2:
+            return json.load(j1) == json.load(j2)
+
+
+def test_zmeta_mesh_cells_timeseries_output(tmp_path):
+    with RasPlanHdf(BALD_EAGLE_P18_TIMESERIES) as phdf:
+        # Generate Zarr metadata
+        zmeta = phdf.zmeta_mesh_cells_timeseries_output("BaldEagleCr")
+
+    # Write the Zarr metadata to JSON
+    zmeta_test_path = tmp_path / "bald-eagle-mesh-cells-zmeta.test.json"
+    with open(zmeta_test_path, "w") as f:
+        json.dump(zmeta, f, indent=4)
+
+    # Compare to a validated JSON file
+    zmeta_valid_path = TEST_JSON / "bald-eagle-mesh-cells-zmeta.json"
+    assert _compare_json(zmeta_test_path, zmeta_valid_path)
+
+    # Verify that the Zarr metadata can be used to open a dataset
+    ds = xr.open_dataset(
+        "reference://",
+        engine="zarr",
+        backend_kwargs={
+            "consolidated": False,
+            "storage_options": {"fo": str(zmeta_test_path)},
+        },
+    )
+    assert ds["Water Surface"].shape == (37, 3947)
+    assert len(ds.coords["time"]) == 37
+    assert len(ds.coords["cell_id"]) == 3947
+    assert ds.attrs["mesh_name"] == "BaldEagleCr"
+
+
+def test_zmeta_mesh_faces_timeseries_output(tmp_path):
+    with RasPlanHdf(BALD_EAGLE_P18_TIMESERIES) as phdf:
+        # Generate Zarr metadata
+        zmeta = phdf.zmeta_mesh_faces_timeseries_output("BaldEagleCr")
+
+    # Write the Zarr metadata to JSON
+    zmeta_test_path = tmp_path / "bald-eagle-mesh-faces-zmeta.test.json"
+    with open(zmeta_test_path, "w") as f:
+        json.dump(zmeta, f, indent=4)
+
+    # Compare to a validated JSON file
+    zmeta_valid_path = TEST_JSON / "bald-eagle-mesh-faces-zmeta.json"
+    assert _compare_json(zmeta_test_path, zmeta_valid_path)
+
+    # Verify that the Zarr metadata can be used to open a dataset
+    ds = xr.open_dataset(
+        "reference://",
+        engine="zarr",
+        backend_kwargs={
+            "consolidated": False,
+            "storage_options": {"fo": str(zmeta_test_path)},
+        },
+    )
+    assert ds["Face Velocity"].shape == (37, 7295)
+    assert len(ds.coords["time"]) == 37
+    assert len(ds.coords["face_id"]) == 7295
+    assert ds.attrs["mesh_name"] == "BaldEagleCr"
+
+
+def test_zmeta_reference_lines_timeseries_output(tmp_path):
+    with RasPlanHdf(BALD_EAGLE_P18_REF) as phdf:
+        # Generate Zarr metadata
+        zmeta = phdf.zmeta_reference_lines_timeseries_output()
+
+    # Write the Zarr metadata to JSON
+    zmeta_test_path = tmp_path / "bald-eagle-reflines-zmeta.test.json"
+    with open(zmeta_test_path, "w") as f:
+        json.dump(zmeta, f, indent=4)
+
+    # Compare to a validated JSON file
+    zmeta_valid_path = TEST_JSON / "bald-eagle-reflines-zmeta.json"
+    assert _compare_json(zmeta_test_path, zmeta_valid_path)
+
+    # Verify that the Zarr metadata can be used to open a dataset
+    ds = xr.open_dataset(
+        "reference://",
+        engine="zarr",
+        backend_kwargs={
+            "consolidated": False,
+            "storage_options": {"fo": str(zmeta_test_path)},
+        },
+    )
+    assert ds["Flow"].shape == (37, 4)
+    assert len(ds.coords["time"]) == 37
+    assert len(ds.coords["refln_id"]) == 4
+    assert ds.attrs == {}
+
+
+def test_zmeta_reference_points_timeseries_output(tmp_path):
+    with RasPlanHdf(BALD_EAGLE_P18_REF) as phdf:
+        # Generate Zarr metadata
+        zmeta = phdf.zmeta_reference_points_timeseries_output()
+
+    # Write the Zarr metadata to JSON
+    zmeta_test_path = tmp_path / "bald-eagle-refpoints-zmeta.test.json"
+    with open(zmeta_test_path, "w") as f:
+        json.dump(zmeta, f, indent=4)
+
+    # Compare to a validated JSON file
+    zmeta_valid_path = TEST_JSON / "bald-eagle-refpoints-zmeta.json"
+    assert _compare_json(zmeta_test_path, zmeta_valid_path)
+
+    # Verify that the Zarr metadata can be used to open a dataset
+    ds = xr.open_dataset(
+        "reference://",
+        engine="zarr",
+        backend_kwargs={
+            "consolidated": False,
+            "storage_options": {"fo": str(zmeta_test_path)},
+        },
+    )
+    assert ds["Water Surface"].shape == (37, 3)
+    assert ds["Velocity"].shape == (37, 3)
+    assert len(ds.coords["time"]) == 37
+    assert len(ds.coords["refpt_id"]) == 3
+    assert ds.attrs == {}
+
+
+def test_mesh_cells_summary_output(tmp_path):
+    with RasPlanHdf(BALD_EAGLE_P18) as phdf:
+        df = phdf.mesh_cells_summary_output()
+        test_csv = tmp_path / "BaldEagleDamBrk.summary-cells.test.csv"
+        df.to_csv(test_csv)
+        filecmp.cmp(
+            test_csv,
+            TEST_CSV / "BaldEagleDamBrk.summary-cells.csv",
+            shallow=False,
+        )
+
+
+def test_mesh_faces_summary_output(tmp_path):
+    with RasPlanHdf(BALD_EAGLE_P18) as phdf:
+        df = phdf.mesh_faces_summary_output()
+        test_csv = tmp_path / "BaldEagleDamBrk.summary-faces.test.csv"
+        df.to_csv(test_csv)
+        filecmp.cmp(
+            test_csv,
+            TEST_CSV / "BaldEagleDamBrk.summary-faces.csv",
+            shallow=False,
+        )
+
+
+def test__mesh_summary_outputs_df(tmp_path):
+    with RasPlanHdf(BALD_EAGLE_P18) as phdf:
+        with pytest.raises(ValueError):
+            phdf._mesh_summary_outputs_df("neither")
+
+        with pytest.raises(ValueError):
+            phdf._mesh_summary_outputs_df(cells_or_faces="cells", output_vars="wrong")
+
+        df = phdf._mesh_summary_outputs_df(
+            cells_or_faces="cells",
+            output_vars=[
+                SummaryOutputVar.MAXIMUM_WATER_SURFACE,
+                SummaryOutputVar.MINIMUM_WATER_SURFACE,
+            ],
+        )
+        test_csv = tmp_path / "BaldEagleDamBrk.summary-cells-selectvars.test.csv"
+        df.to_csv(test_csv)
+        filecmp.cmp(
+            test_csv,
+            TEST_CSV / "BaldEagleDamBrk.summary-cells-selectvars.csv",
+            shallow=False,
+        )
+
+
+def test_observed_timeseries_input_flow():
+    with RasPlanHdf(DENTON) as phdf:
+        ds = phdf.observed_timeseries_input(vartype="Flow")
+        df = ds.sel(refln_name="Denton-Justin_RL").to_dataframe().dropna().reset_index()
+        valid_df = pd.read_csv(TEST_CSV / "Denton-Justin_RL_Flow.csv")
+        valid_df["time"] = pd.to_datetime(valid_df["time"])
+        assert_frame_equal(df, valid_df)
+
+
+def test_observed_timeseries_input_stage():
+    with RasPlanHdf(DENTON) as phdf:
+        ds = phdf.observed_timeseries_input(vartype="Stage")
+        df = (
+            ds.sel(refpt_name="Grapevine_Lake_RP").to_dataframe().dropna().reset_index()
+        )
+        valid_df = pd.read_csv(TEST_CSV / "Grapevine_Lake_RP_Stage.csv")
+        valid_df["time"] = pd.to_datetime(valid_df["time"])
+        assert_frame_equal(df, valid_df)
+
+
+def test_observed_timeseries_input_value_error():
+    with RasPlanHdf(DENTON) as phdf:
+        with pytest.raises(ValueError):
+            phdf.observed_timeseries_input(vartype="Fake Variable")
+
+
+def test_observed_timeseries_input_rasplanhdf_error():
+    with RasPlanHdf(BALD_EAGLE_P18) as phdf:
+        with pytest.raises(RasPlanHdfError):
+            phdf.observed_timeseries_input(vartype="Flow")