rashdf 0.7.2__tar.gz → 0.8.1__tar.gz

{rashdf-0.7.2 → rashdf-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: rashdf
-Version: 0.7.2
+Version: 0.8.1
 Summary: Read data from HEC-RAS HDF files.
 Project-URL: repository, https://github.com/fema-ffrd/rashdf
 Classifier: Development Status :: 4 - Beta
@@ -16,7 +16,7 @@ License-File: LICENSE
 Requires-Dist: h5py
 Requires-Dist: geopandas<2.0,>=1.0
 Requires-Dist: pyarrow
-Requires-Dist: xarray
+Requires-Dist: xarray<=2025.4.0
 Provides-Extra: dev
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
@@ -28,10 +28,12 @@ Requires-Dist: dask; extra == "dev"
 Requires-Dist: fsspec; extra == "dev"
 Requires-Dist: s3fs; extra == "dev"
 Requires-Dist: fiona==1.9.6; extra == "dev"
+Requires-Dist: numcodecs<0.16; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: numpydoc; extra == "docs"
 Requires-Dist: sphinx_rtd_theme; extra == "docs"
+Dynamic: license-file
 
 # rashdf
 [![CI](https://github.com/fema-ffrd/rashdf/actions/workflows/continuous-integration.yml/badge.svg?branch=main)](https://github.com/fema-ffrd/rashdf/actions/workflows/continuous-integration.yml)

{rashdf-0.7.2 → rashdf-0.8.1}/pyproject.toml

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

{rashdf-0.7.2 → rashdf-0.8.1}/src/cli.py

@@ -21,6 +21,7 @@ COMMANDS = [
     "mesh_cell_faces",
     "refinement_regions",
     "bc_lines",
+    "ic_points",
     "breaklines",
     "reference_lines",
     "reference_points",

{rashdf-0.7.2 → rashdf-0.8.1}/src/rashdf/geom.py

@@ -17,6 +17,8 @@ from shapely import (
 )
 
 from typing import Dict, List, Optional, Union
+from warnings import warn
+from pathlib import Path
 
 
 from .base import RasHdf
@@ -29,7 +31,7 @@ from .utils import (
 
 
 class RasGeomHdfError(Exception):
-    """HEC-RAS Plan HDF error class."""
+    """HEC-RAS Geometry HDF error class."""
 
     pass
 
@@ -41,7 +43,9 @@ class RasGeomHdf(RasHdf):
     GEOM_STRUCTURES_PATH = f"{GEOM_PATH}/Structures"
     FLOW_AREA_2D_PATH = f"{GEOM_PATH}/2D Flow Areas"
     BC_LINES_PATH = f"{GEOM_PATH}/Boundary Condition Lines"
+    IC_POINTS_PATH = f"{GEOM_PATH}/IC Points"
     BREAKLINES_PATH = f"{GEOM_PATH}/2D Flow Area Break Lines"
+    REFINEMENT_REGIONS_PATH = f"{GEOM_PATH}/2D Flow Area Refinement Regions"
     REFERENCE_LINES_PATH = f"{GEOM_PATH}/Reference Lines"
     REFERENCE_POINTS_PATH = f"{GEOM_PATH}/Reference Points"
     CROSS_SECTIONS = f"{GEOM_PATH}/Cross Sections"
@@ -294,19 +298,28 @@ class RasGeomHdf(RasHdf):
         polyline_points = self[polyline_points_path][()]
 
         geoms = []
-        for pnt_start, pnt_cnt, part_start, part_cnt in polyline_info:
-            points = polyline_points[pnt_start : pnt_start + pnt_cnt]
-            if part_cnt == 1:
-                geoms.append(LineString(points))
-            else:
-                parts = polyline_parts[part_start : part_start + part_cnt]
-                geoms.append(
-                    MultiLineString(
-                        list(
-                            points[part_pnt_start : part_pnt_start + part_pnt_cnt]
-                            for part_pnt_start, part_pnt_cnt in parts
+        for i, (pnt_start, pnt_cnt, part_start, part_cnt) in enumerate(polyline_info):
+            try:
+                points = polyline_points[pnt_start : pnt_start + pnt_cnt]
+                if part_cnt == 1:
+                    geoms.append(LineString(points))
+                else:  # pragma: no cover | TODO: add test coverage for this
+                    parts = polyline_parts[part_start : part_start + part_cnt]
+                    geoms.append(
+                        MultiLineString(
+                            list(
+                                points[part_pnt_start : part_pnt_start + part_pnt_cnt]
+                                for part_pnt_start, part_pnt_cnt in parts
+                            )
                         )
                     )
+            except (
+                Exception
+            ) as e:  # pragma: no cover | TODO: add test coverage for this
+                geoms.append(None)
+                warn(
+                    f"Feature ID {i} within '{Path(path).name}' layer set to null due to invalid geometry. {e}",
+                    UserWarning,
                 )
         return geoms
 
@@ -369,25 +382,38 @@ class RasGeomHdf(RasHdf):
         GeoDataFrame
             A GeoDataFrame containing the 2D mesh area refinement regions if they exist.
         """
-        if "/Geometry/2D Flow Area Refinement Regions" not in self:
+        if self.REFINEMENT_REGIONS_PATH not in self:
             return GeoDataFrame()
-        rr_data = self["/Geometry/2D Flow Area Refinement Regions"]
+        rr_data = self[self.REFINEMENT_REGIONS_PATH]
         rr_ids = range(rr_data["Attributes"][()].shape[0])
         names = np.vectorize(convert_ras_hdf_string)(rr_data["Attributes"][()]["Name"])
         geoms = list()
-        for pnt_start, pnt_cnt, part_start, part_cnt in rr_data["Polygon Info"][()]:
-            points = rr_data["Polygon Points"][()][pnt_start : pnt_start + pnt_cnt]
-            if part_cnt == 1:
-                geoms.append(Polygon(points))
-            else:
-                parts = rr_data["Polygon Parts"][()][part_start : part_start + part_cnt]
-                geoms.append(
-                    MultiPolygon(
-                        list(
-                            points[part_pnt_start : part_pnt_start + part_pnt_cnt]
-                            for part_pnt_start, part_pnt_cnt in parts
+        for i, (pnt_start, pnt_cnt, part_start, part_cnt) in enumerate(
+            rr_data["Polygon Info"][()]
+        ):
+            try:
+                points = rr_data["Polygon Points"][()][pnt_start : pnt_start + pnt_cnt]
+                if part_cnt == 1:
+                    geoms.append(Polygon(points))
+                else:  # pragma: no cover | TODO: add test coverage for this
+                    parts = rr_data["Polygon Parts"][()][
+                        part_start : part_start + part_cnt
+                    ]
+                    geoms.append(
+                        MultiPolygon(
+                            list(
+                                points[part_pnt_start : part_pnt_start + part_pnt_cnt]
+                                for part_pnt_start, part_pnt_cnt in parts
+                            )
                         )
                     )
+            except (
+                Exception
+            ) as e:  # pragma: no cover | TODO: add test coverage for this
+                geoms.append(None)
+                warn(
+                    f"Feature ID {i} within '{Path(self.REFINEMENT_REGIONS_PATH).name}' layer set to null due to invalid geometry. {e}",
+                    UserWarning,
                 )
         return GeoDataFrame(
             {"rr_id": rr_ids, "name": names, "geometry": geoms},
@@ -408,7 +434,10 @@ class RasGeomHdf(RasHdf):
         GeoDataFrame
             A GeoDataFrame containing the model structures if they exist.
         """
-        if self.GEOM_STRUCTURES_PATH not in self:
+        if (
+            self.GEOM_STRUCTURES_PATH not in self
+            or f"{self.GEOM_STRUCTURES_PATH}/Attributes" not in self
+        ):
             return GeoDataFrame()
         struct_data = self[self.GEOM_STRUCTURES_PATH]
         v_conv_val = np.vectorize(convert_ras_hdf_value)
@@ -438,7 +467,32 @@ class RasGeomHdf(RasHdf):
         raise NotImplementedError
 
     def ic_points(self) -> GeoDataFrame:  # noqa D102
-        raise NotImplementedError
+        """Return initial conditions points.
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the initial condition points if they exist.
+        """
+        if self.IC_POINTS_PATH not in self:
+            return GeoDataFrame()
+        ic_data = self[self.IC_POINTS_PATH]
+        v_conv_str = np.vectorize(convert_ras_hdf_string)
+        names = v_conv_str(ic_data["Attributes"][()]["Name"])
+        mesh_names = v_conv_str(ic_data["Attributes"][()]["SA/2D"])
+        cell_ids = ic_data["Attributes"][()]["Cell Index"]
+        points = ic_data["Points"][()]
+        return GeoDataFrame(
+            {
+                "icpt_id": range(len(names)),
+                "icpt_name": names,
+                "mesh_name": mesh_names,
+                "cell_id": cell_ids,
+                "geometry": list(map(Point, points)),
+            },
+            geometry="geometry",
+            crs=self.projection(),
+        )
 
     def _reference_lines_points_names(
         self, reftype: str = "lines", mesh_name: Optional[str] = None

{rashdf-0.7.2 → rashdf-0.8.1}/src/rashdf/plan.py

@@ -168,6 +168,7 @@ 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"
+    BOUNDARY_CONDITIONS_OUTPUT_PATH = f"{UNSTEADY_TIME_SERIES_PATH}/Boundary Conditions"
     OBS_FLOW_OUTPUT_PATH = f"{OBS_DATA_PATH}/Flow"
     OBS_STAGE_OUTPUT_PATH = f"{OBS_DATA_PATH}/Stage"
 
@@ -1121,6 +1122,81 @@ class RasPlanHdf(RasGeomHdf):
         """
         return self.reference_timeseries_output(reftype="lines")
 
+    def bc_line_timeseries_output(self, bc_line_name: str) -> xr.Dataset:
+        """Return timeseries output data for a specific boundary condition line from a HEC-RAS HDF plan file.
+
+        Parameters
+        ----------
+        bc_line_name : str
+            The name of the boundary condition line.
+
+        Returns
+        -------
+        xr.Dataset
+            An xarray Dataset with timeseries output data for the specified boundary condition line.
+        """
+        path = f"{self.BOUNDARY_CONDITIONS_OUTPUT_PATH}/{bc_line_name}"
+        dataset = self.get(path)
+        if dataset is None:
+            raise RasPlanHdfError(
+                f"Could not find HDF group at path '{path}'."
+                f" Does the Plan HDF file contain boundary condition output data for '{bc_line_name}'?"
+            )
+        columns = [c.decode("utf-8") for c in dataset.attrs["Columns"]]
+        ds = xr.Dataset()
+        try:
+            import dask.array as da
+
+            # TODO: user-specified chunks?
+            values = da.from_array(dataset, chunks=dataset.chunks)
+        except ImportError:
+            values = dataset[:]
+        for i, col in enumerate(columns):
+            units = dataset.attrs.get(col, None)
+            if units is not None:
+                units = units.decode("utf-8")
+            da = xr.DataArray(
+                values[:, i],
+                name=col,
+                dims=["time"],
+                coords={
+                    "time": self.unsteady_datetimes(),
+                },
+                attrs={
+                    "units": units,
+                    "hdf_path": f"{path}",
+                },
+            )
+            ds[col] = da
+        return ds
+
+    def bc_lines_timeseries_output(self) -> xr.Dataset:
+        """Return timeseries output data for boundary conditions lines from a HEC-RAS HDF plan file.
+
+        Returns
+        -------
+        xr.Dataset
+            An xarray Dataset with timeseries output data for boundary conditions lines.
+        """
+        df_bc_lines = self.bc_lines()
+        bc_lines_names = df_bc_lines["name"]
+        datasets = []
+        for bc_line_name in bc_lines_names:
+            ds_bc_line = self.bc_line_timeseries_output(bc_line_name)
+            datasets.append(ds_bc_line)
+        bc_line_ids = df_bc_lines["bc_line_id"].values
+        ds: xr.Dataset = xr.concat(
+            datasets, dim=pd.Index(bc_line_ids, name="bc_line_id")
+        )
+        ds = ds.assign_coords(
+            {
+                "bc_line_name": ("bc_line_id", bc_lines_names),
+                "bc_line_type": ("bc_line_id", df_bc_lines["type"]),
+                "mesh_name": ("bc_line_id", df_bc_lines["mesh_name"]),
+            }
+        )
+        return ds
+
     def observed_timeseries_input(self, vartype: str = "Flow") -> xr.DataArray:
         """Return observed timeseries input data for reference lines and points from a HEC-RAS HDF plan file.
 
@@ -1381,10 +1457,49 @@ class RasPlanHdf(RasGeomHdf):
         """
         return self.get_attrs(self.VOLUME_ACCOUNTING_PATH)
 
-    def enroachment_points(self) -> GeoDataFrame:  # noqa: D102
-        raise NotImplementedError
+    def encroachment_points(self, profile_name: str) -> GeoDataFrame:
+        """Return encroachment points from a HEC-RAS plan HDF file based on a user-specified flow profile.
+
+        Returns
+        -------
+        GeoDataframe
+            A GeoDataFrame with cross-section encroachments represented as Point geometry features along with pertinent attributes.
+        """
+        cross_sections = self.cross_sections()
+        cross_sections["Enc_Profile"] = profile_name
+
+        leftmost_sta = self.cross_sections_elevations()["elevation info"].apply(
+            lambda x: x[0][0]
+        )
+        left_enc_sta = self.cross_sections_additional_enc_station_left()[profile_name]
+        left_enc_points = GeoDataFrame(
+            pd.concat(
+                [
+                    cross_sections[["River", "Reach", "RS", "Enc_Profile"]],
+                    left_enc_sta.rename("Enc_Sta", inplace=False),
+                ],
+                axis=1,
+            ),
+            geometry=cross_sections.geometry.interpolate(left_enc_sta - leftmost_sta),
+        )
+        left_enc_points["Side"] = "Left"
+
+        right_enc_sta = self.cross_sections_additional_enc_station_right()[profile_name]
+        right_enc_points = GeoDataFrame(
+            pd.concat(
+                [
+                    cross_sections[["River", "Reach", "RS", "Enc_Profile"]],
+                    right_enc_sta.rename("Enc_Sta", inplace=False),
+                ],
+                axis=1,
+            ),
+            geometry=cross_sections.geometry.interpolate(right_enc_sta - leftmost_sta),
+        )
+        right_enc_points["Side"] = "Right"
+
+        return GeoDataFrame(pd.concat([left_enc_points, right_enc_points]))
 
-    def steady_flow_names(self) -> list:
+    def steady_flow_names(self) -> List[str]:
         """Return the profile information for each steady flow event.
 
         Returns
@@ -1393,7 +1508,7 @@ class RasPlanHdf(RasGeomHdf):
             A Dataframe containing the profile names for each event
         """
         if self.STEADY_PROFILES_PATH not in self:
-            return pd.DataFrame()
+            return []
 
         profile_data = self[self.STEADY_PROFILES_PATH]
         profile_attrs = profile_data["Profile Names"][()]

{rashdf-0.7.2 → rashdf-0.8.1}/src/rashdf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: rashdf
-Version: 0.7.2
+Version: 0.8.1
 Summary: Read data from HEC-RAS HDF files.
 Project-URL: repository, https://github.com/fema-ffrd/rashdf
 Classifier: Development Status :: 4 - Beta
@@ -16,7 +16,7 @@ License-File: LICENSE
 Requires-Dist: h5py
 Requires-Dist: geopandas<2.0,>=1.0
 Requires-Dist: pyarrow
-Requires-Dist: xarray
+Requires-Dist: xarray<=2025.4.0
 Provides-Extra: dev
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
@@ -28,10 +28,12 @@ Requires-Dist: dask; extra == "dev"
 Requires-Dist: fsspec; extra == "dev"
 Requires-Dist: s3fs; extra == "dev"
 Requires-Dist: fiona==1.9.6; extra == "dev"
+Requires-Dist: numcodecs<0.16; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: numpydoc; extra == "docs"
 Requires-Dist: sphinx_rtd_theme; extra == "docs"
+Dynamic: license-file
 
 # rashdf
 [![CI](https://github.com/fema-ffrd/rashdf/actions/workflows/continuous-integration.yml/badge.svg?branch=main)](https://github.com/fema-ffrd/rashdf/actions/workflows/continuous-integration.yml)

{rashdf-0.7.2 → rashdf-0.8.1}/src/rashdf.egg-info/requires.txt

@@ -1,7 +1,7 @@
 h5py
 geopandas<2.0,>=1.0
 pyarrow
-xarray
+xarray<=2025.4.0
 
 [dev]
 pre-commit
@@ -14,6 +14,7 @@ dask
 fsspec
 s3fs
 fiona==1.9.6
+numcodecs<0.16
 
 [docs]
 sphinx

{rashdf-0.7.2 → rashdf-0.8.1}/tests/test_geom.py

@@ -1,7 +1,10 @@
+import geopandas as gpd
 from pathlib import Path
 import h5py
 from pyproj import CRS
 from src.rashdf import RasGeomHdf
+from pandas.testing import assert_frame_equal
+import pytest
 
 from . import _create_hdf_with_group_attrs, _gdf_matches_json, _gdf_matches_json_alt
 
@@ -11,6 +14,8 @@ COAL_G01 = TEST_DATA / "ras/Coal.g01.hdf"
 BAXTER_P01 = TEST_DATA / "ras_1d/Baxter.p01.hdf"
 TEST_JSON = TEST_DATA / "json"
 BALD_EAGLE_P18_REF = TEST_DATA / "ras/BaldEagleDamBrk.reflines-refpts.p18.hdf"
+LOWER_KANAWHA_P01_IC_POINTS = TEST_DATA / "ras/LowerKanawha.p01.icpoints.hdf"
+LOWER_KANAWHA_P01_IC_POINTS_JSON = TEST_JSON / "LowerKanawha.p01.icpoints.geojson"
 
 TEST_ATTRS = {"test_attribute1": "test_str1", "test_attribute2": 500}
 
@@ -31,30 +36,71 @@ def test_mesh_area_names():
         assert ghdf.mesh_area_names() == ["2D Interior Area", "Perimeter_NW"]
 
 
+def test_invalid_mesh_area_names(tmp_path):
+    test_hdf = tmp_path / "test.hdf"
+    _create_hdf_with_group_attrs(test_hdf, RasGeomHdf.GEOM_PATH, TEST_ATTRS)
+    # Test the empty Mesh Area names
+    with RasGeomHdf(test_hdf) as ghdf:
+        assert ghdf.mesh_area_names() == []
+
+
 def test_mesh_areas():
     mesh_areas_json = TEST_JSON / "mesh_areas.json"
     with RasGeomHdf(MUNCIE_G05) as ghdf:
         assert _gdf_matches_json(ghdf.mesh_areas(), mesh_areas_json)
 
 
+def test_invalid_mesh_areas(tmp_path):
+    test_hdf = tmp_path / "test.hdf"
+    _create_hdf_with_group_attrs(test_hdf, RasGeomHdf.GEOM_PATH, TEST_ATTRS)
+    # Test the empty Mesh Areas
+    with RasGeomHdf(test_hdf) as ghdf:
+        assert ghdf.mesh_areas().empty
+
+
 def test_mesh_cell_faces():
     mesh_cell_faces_json = TEST_JSON / "mesh_cell_faces.json"
     with RasGeomHdf(MUNCIE_G05) as ghdf:
         assert _gdf_matches_json(ghdf.mesh_cell_faces(), mesh_cell_faces_json)
 
 
+def test_invalid_mesh_faces(tmp_path):
+    test_hdf = tmp_path / "test.hdf"
+    _create_hdf_with_group_attrs(test_hdf, RasGeomHdf.GEOM_PATH, TEST_ATTRS)
+    # Test the empty Mesh Faces
+    with RasGeomHdf(test_hdf) as ghdf:
+        assert ghdf.mesh_cell_faces().empty
+
+
 def test_mesh_cell_points():
     mesh_cell_points_json = TEST_JSON / "mesh_cell_points.json"
     with RasGeomHdf(MUNCIE_G05) as ghdf:
         assert _gdf_matches_json(ghdf.mesh_cell_points(), mesh_cell_points_json)
 
 
+def test_invalid_mesh_cell_points(tmp_path):
+    test_hdf = tmp_path / "test.hdf"
+    _create_hdf_with_group_attrs(test_hdf, RasGeomHdf.GEOM_PATH, TEST_ATTRS)
+    # Test the empty Mesh Cell Points
+    with RasGeomHdf(test_hdf) as ghdf:
+        assert ghdf.mesh_cell_points().empty
+
+
 def test_mesh_cell_polygons():
     mesh_cell_polygons_json = TEST_JSON / "mesh_cell_polygons.json"
     with RasGeomHdf(MUNCIE_G05) as ghdf:
         assert _gdf_matches_json(ghdf.mesh_cell_polygons(), mesh_cell_polygons_json)
 
 
+def test_invalid_mesh_cell_polygons(tmp_path):
+    # Create a dummy HDF file
+    test_hdf = tmp_path / "test.hdf"
+    _create_hdf_with_group_attrs(test_hdf, RasGeomHdf.GEOM_PATH, TEST_ATTRS)
+    # Test the empty Mesh Cell Polygons
+    with RasGeomHdf(test_hdf) as ghdf:
+        assert ghdf.mesh_cell_polygons().empty
+
+
 def test_mesh_cell_polygons_coal():
     """Test with the mesh from the Coal River model.
 
@@ -114,6 +160,18 @@ def test_get_geom_2d_flow_area_attrs(tmp_path):
     assert ras_hdf.get_geom_2d_flow_area_attrs() == TEST_ATTRS
 
 
+def test_invalid_get_geom_2d_flow_area_attrs(tmp_path):
+    test_hdf = tmp_path / "test.hdf"
+    _create_hdf_with_group_attrs(test_hdf, RasGeomHdf.GEOM_PATH, TEST_ATTRS)
+    ras_hdf = RasGeomHdf(test_hdf)
+
+    with pytest.raises(
+        AttributeError,
+        match=f"Unable to get 2D Flow Area; {RasGeomHdf.FLOW_AREA_2D_PATH} group not found in HDF5 file.",
+    ):
+        ras_hdf.get_geom_2d_flow_area_attrs()
+
+
 def test_structs():
     structs_json = TEST_JSON / "structures.json"
     with RasGeomHdf(MUNCIE_G05) as ghdf:
@@ -151,7 +209,7 @@ def test_reference_points_names():
 
 def test_structs_not_found():
     with RasGeomHdf(COAL_G01) as ghdf:
-        assert (ghdf.structures(), None)
+        assert ghdf.structures().empty
 
 
 def test_cross_sections():
@@ -164,7 +222,7 @@ def test_cross_sections():
 
 def test_cross_sections_not_found():
     with RasGeomHdf(COAL_G01) as ghdf:
-        assert (ghdf.cross_sections(), None)
+        assert ghdf.cross_sections().empty
 
 
 def test_river_reaches():
@@ -175,7 +233,7 @@ def test_river_reaches():
 
 def test_river_reaches_not_found():
     with RasGeomHdf(COAL_G01) as ghdf:
-        assert (ghdf.river_reaches(), None)
+        assert ghdf.river_reaches().empty
 
 
 def test_cross_sections_elevations():
@@ -186,4 +244,18 @@ def test_cross_sections_elevations():
 
 def test_cross_sections_elevations_not_found():
     with RasGeomHdf(COAL_G01) as ghdf:
-        assert (ghdf.cross_sections_elevations(), None)
+        assert ghdf.cross_sections_elevations().empty
+
+
+def test_ic_points():
+    with RasGeomHdf(LOWER_KANAWHA_P01_IC_POINTS) as ghdf:
+        gdf_ic_points = ghdf.ic_points()
+        valid_gdf = gpd.read_file(
+            LOWER_KANAWHA_P01_IC_POINTS_JSON,
+            crs=ghdf.projection(),
+        )
+        assert_frame_equal(
+            gdf_ic_points,
+            valid_gdf,
+            check_dtype=False,
+        )

{rashdf-0.7.2 → rashdf-0.8.1}/tests/test_plan.py

@@ -5,9 +5,11 @@ from src.rashdf.plan import (
     TimeSeriesOutputVar,
 )
 
+import builtins
 import filecmp
 import json
 from pathlib import Path
+from unittest import mock
 
 import numpy as np
 import pandas as pd
@@ -32,6 +34,7 @@ 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"
+LOWER_KANAWHA_P01_BC_LINES = TEST_DATA / "ras/LowerKanawha.p01.bclines.hdf"
 BAXTER_P01 = TEST_DATA / "ras_1d/Baxter.p01.hdf"
 FLODENCR_P01 = TEST_DATA / "ras_1d/FLODENCR.p01.hdf"
 
@@ -322,6 +325,59 @@ def test_reference_lines_timeseries(tmp_path: Path):
     assert_frame_equal(df, valid_df)
 
 
+def test_bc_lines_timeseries(tmp_path: Path):
+    plan_hdf = RasPlanHdf(LOWER_KANAWHA_P01_BC_LINES)
+    ds = plan_hdf.bc_lines_timeseries_output()
+    assert "time" in ds.coords
+    assert "bc_line_id" in ds.coords
+    assert "bc_line_name" in ds.coords
+    assert "mesh_name" in ds.coords
+    assert "Flow" in ds.variables
+    assert "Stage" in ds.variables
+
+    q = ds["Flow"]
+    assert q.chunks is not None  # Ensure Dask chunks are set
+    assert q.shape == (10, 577)
+    assert q.attrs["units"] == "cfs"
+
+    stage = ds["Stage"]
+    assert stage.chunks is not None  # Ensure Dask chunks are set
+    assert stage.shape == (10, 577)
+    assert stage.attrs["units"] == "ft"
+
+    df = ds.sel(bc_line_id=7).to_dataframe()
+    valid_df = pd.read_csv(
+        TEST_CSV / "LowerKanawha.p01.bclines.7.csv",
+        index_col="time",
+        parse_dates=True,
+        dtype={"Flow": np.float32, "Stage": np.float32},
+    )
+    assert_frame_equal(df, valid_df)
+
+
+def test_bc_lines_timeseries_no_dask(monkeypatch):
+    """Test that the bc_lines_timeseries_output method works without Dask."""
+    original_import = builtins.__import__
+
+    def mocked_import(name, *args, **kwargs):
+        if name == "dask.array":
+            raise ImportError("Dask is not available")
+        return original_import(name, *args, **kwargs)
+
+    monkeypatch.setattr(builtins, "__import__", mocked_import)
+
+    plan_hdf = RasPlanHdf(LOWER_KANAWHA_P01_BC_LINES)
+    ds = plan_hdf.bc_lines_timeseries_output()
+    assert ds["Flow"].chunks is None  # Ensure no Dask chunks are set
+    assert ds["Stage"].chunks is None
+
+
+def test_bc_line_timeseries_error():
+    plan_hdf = RasPlanHdf(LOWER_KANAWHA_P01_BC_LINES)
+    with pytest.raises(RasPlanHdfError):
+        plan_hdf.bc_line_timeseries_output("asdf")
+
+
 def test_reference_points(tmp_path: Path):
     plan_hdf = RasPlanHdf(BALD_EAGLE_P18_REF)
     gdf = plan_hdf.reference_points(datetime_to_str=True)
@@ -371,7 +427,7 @@ def test_cross_sections_additional_velocity_total():
 
 def test_cross_sections_additional_velocity_total_not_found():
     with RasPlanHdf(COAL_G01) as phdf:
-        assert (phdf.cross_sections_additional_velocity_total(), None)
+        assert phdf.cross_sections_additional_velocity_total().empty
 
 
 def test_cross_sections_additional_area_total():
@@ -384,7 +440,7 @@ def test_cross_sections_additional_area_total():
 
 def test_cross_sections_additional_area_total_not_found():
     with RasPlanHdf(COAL_G01) as phdf:
-        assert (phdf.cross_sections_additional_area_total(), None)
+        assert phdf.cross_sections_additional_area_total().empty
 
 
 def test_steady_flow_names():
@@ -394,7 +450,7 @@ def test_steady_flow_names():
 
 def test_steady_flow_names_not_found():
     with RasPlanHdf(COAL_G01) as phdf:
-        assert (phdf.steady_flow_names(), None)
+        assert phdf.steady_flow_names() == []
 
 
 def test_cross_sections_wsel():
@@ -405,7 +461,7 @@ def test_cross_sections_wsel():
 
 def test_cross_sections_wsel_not_found():
     with RasPlanHdf(COAL_G01) as phdf:
-        assert (phdf.cross_sections_wsel(), None)
+        assert phdf.cross_sections_wsel().empty
 
 
 def test_cross_sections_additional_enc_station_right():
@@ -419,7 +475,7 @@ def test_cross_sections_additional_enc_station_right():
 
 def test_cross_sections_additional_enc_station_right_not_found():
     with RasPlanHdf(COAL_G01) as phdf:
-        assert (phdf.cross_sections_additional_enc_station_right(), None)
+        assert phdf.cross_sections_additional_enc_station_right().empty
 
 
 def test_cross_sections_additional_enc_station_left():
@@ -432,7 +488,7 @@ def test_cross_sections_additional_enc_station_left():
 
 def test_cross_sections_additional_enc_station_left_not_found():
     with RasPlanHdf(COAL_G01) as phdf:
-        assert (phdf.cross_sections_additional_enc_station_left(), None)
+        assert phdf.cross_sections_additional_enc_station_left().empty
 
 
 def test_cross_sections_flow():
@@ -650,3 +706,12 @@ def test_observed_timeseries_input_rasplanhdf_error():
     with RasPlanHdf(BALD_EAGLE_P18) as phdf:
         with pytest.raises(RasPlanHdfError):
             phdf.observed_timeseries_input(vartype="Flow")
+
+
+def test_encroachment_points():
+    enc_pnts_json = TEST_JSON / "encroachment_points.json"
+    with RasPlanHdf(FLODENCR_P01) as phdf:
+        assert _gdf_matches_json_alt(
+            phdf.encroachment_points(profile_name="PF#2"),
+            enc_pnts_json,
+        )