rashdf 0.3.0__tar.gz → 0.5.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rashdf
-Version: 0.3.0
+Version: 0.5.0
 Summary: Read data from HEC-RAS HDF files.
 Project-URL: repository, https://github.com/fema-ffrd/rashdf
 Classifier: Development Status :: 4 - Beta
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: h5py
-Requires-Dist: geopandas
+Requires-Dist: geopandas<2.0,>=1.0
 Requires-Dist: pyarrow
 Requires-Dist: xarray
 Provides-Extra: dev
@@ -22,6 +22,7 @@ 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"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: numpydoc; extra == "docs"
@@ -76,8 +77,8 @@ Also, methods to extract certain HDF group attributes as dictionaries:
 ```python
 >>> from rashdf import RasPlanHdf
 >>> with RasPlanHdf("path/to/rasmodel/Muncie.p04.hdf") as plan_hdf:
->>> results_unsteady_summary = plan_hdf.get_results_unsteady_summary()
->>> results_unsteady_summary
+>>> results_unsteady_summary_attrs = plan_hdf.get_results_unsteady_summary_attrs()
+>>> results_unsteady_summary_attrs
 {'Computation Time DSS': datetime.timedelta(0),
 'Computation Time Total': datetime.timedelta(seconds=23),
 'Maximum WSEL Error': 0.0099277812987566,
@@ -101,9 +102,9 @@ CLI help:
 $ rashdf --help
 ```
 
-Print the output formats supported by Fiona:
+Print the output formats supported by pyorgio:
 ```
-$ rashdf --fiona-drivers
+$ rashdf --pyogrio-drivers
 ```
 
 Help for a specific subcommand:

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

@@ -47,8 +47,8 @@ Also, methods to extract certain HDF group attributes as dictionaries:
 ```python
 >>> from rashdf import RasPlanHdf
 >>> with RasPlanHdf("path/to/rasmodel/Muncie.p04.hdf") as plan_hdf:
->>> results_unsteady_summary = plan_hdf.get_results_unsteady_summary()
->>> results_unsteady_summary
+>>> results_unsteady_summary_attrs = plan_hdf.get_results_unsteady_summary_attrs()
+>>> results_unsteady_summary_attrs
 {'Computation Time DSS': datetime.timedelta(0),
 'Computation Time Total': datetime.timedelta(seconds=23),
 'Maximum WSEL Error': 0.0099277812987566,
@@ -72,9 +72,9 @@ CLI help:
 $ rashdf --help
 ```
 
-Print the output formats supported by Fiona:
+Print the output formats supported by pyorgio:
 ```
-$ rashdf --fiona-drivers
+$ rashdf --pyogrio-drivers
 ```
 
 Help for a specific subcommand:

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

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

{rashdf-0.3.0 → rashdf-0.5.0}/src/cli.py

@@ -3,7 +3,6 @@
 from rashdf import RasGeomHdf, RasPlanHdf
 from rashdf.utils import df_datetimes_to_str
 
-import fiona
 from geopandas import GeoDataFrame
 
 import argparse
@@ -23,6 +22,8 @@ COMMANDS = [
     "refinement_regions",
     "bc_lines",
     "breaklines",
+    "reference_lines",
+    "reference_points",
     "structures",
 ]
 
@@ -50,6 +51,20 @@ def docstring_to_help(docstring: Optional[str]) -> str:
     return help_text
 
 
+def pyogrio_supported_drivers() -> List[str]:
+    """Return a list of drivers supported by pyogrio for writing output files.
+
+    Returns
+    -------
+    list
+        A list of drivers supported by pyogrio for writing output files.
+    """
+    import pyogrio
+
+    drivers = pyogrio.list_drivers(write=True)
+    return sorted(drivers)
+
+
 def fiona_supported_drivers() -> List[str]:
     """Return a list of drivers supported by Fiona for writing output files.
 
@@ -58,18 +73,34 @@ def fiona_supported_drivers() -> List[str]:
     list
         A list of drivers supported by Fiona for writing output files.
     """
+    import fiona
+
     drivers = [d for d, s in fiona.supported_drivers.items() if "w" in s]
-    return drivers
+    return sorted(drivers)
 
 
 def parse_args(args: str) -> argparse.Namespace:
     """Parse command-line arguments."""
     parser = argparse.ArgumentParser(description="Extract data from HEC-RAS HDF files.")
     parser.add_argument(
-        "--fiona-drivers",
+        "--pyogrio-drivers",
         action="store_true",
-        help="List the drivers supported by Fiona for writing output files.",
+        help="List the drivers supported by pyogrio for writing output files.",
     )
+    fiona_installed = False
+    engines = ["pyogrio"]
+    try:
+        import fiona
+
+        fiona_installed = True
+        engines.append("fiona")
+        parser.add_argument(
+            "--fiona-drivers",
+            action="store_true",
+            help="List the drivers supported by Fiona for writing output files.",
+        )
+    except ImportError:
+        pass
     subparsers = parser.add_subparsers(help="Sub-command help")
     for command in COMMANDS:
         f = getattr(RasGeomHdf, command)
@@ -91,6 +122,13 @@ def parse_args(args: str) -> argparse.Namespace:
         output_group.add_argument(
             "--feather", action="store_true", help="Output as Feather."
         )
+        output_group.add_argument(
+            "--engine",
+            type=str,
+            choices=engines,
+            default="pyogrio",
+            help="Engine for writing output data.",
+        )
         subparser.add_argument(
             "--kwargs",
             type=str,
@@ -105,7 +143,11 @@ def parse_args(args: str) -> argparse.Namespace:
 
 def export(args: argparse.Namespace) -> Optional[str]:
     """Act on parsed arguments to extract data from HEC-RAS HDF files."""
-    if args.fiona_drivers:
+    if args.pyogrio_drivers:
+        for driver in pyogrio_supported_drivers():
+            print(driver)
+        return
+    if hasattr(args, "fiona_drivers") and args.fiona_drivers:
         for driver in fiona_supported_drivers():
             print(driver)
         return
@@ -138,6 +180,7 @@ def export(args: argparse.Namespace) -> Optional[str]:
                 ),
             )
             result = gdf.to_json(**kwargs)
+        print("No output file!")
         print(result)
         return result
     elif args.parquet:
@@ -153,7 +196,7 @@ def export(args: argparse.Namespace) -> Optional[str]:
         # convert any datetime columns to string.
         # TODO: besides Geopackage, which of the standard Fiona drivers allow datetime?
         gdf = df_datetimes_to_str(gdf)
-    gdf.to_file(args.output_file, **kwargs)
+    gdf.to_file(args.output_file, engine=args.engine, **kwargs)
 
 
 def main():

{rashdf-0.3.0 → rashdf-0.5.0}/src/rashdf/geom.py

@@ -1,27 +1,37 @@
 """HEC-RAS Geometry HDF class."""
 
-from .base import RasHdf
-from .utils import (
-    convert_ras_hdf_string,
-    get_first_hdf_group,
-    hdf5_attrs_to_dict,
-    convert_ras_hdf_value,
-)
-
 import numpy as np
 import pandas as pd
 from geopandas import GeoDataFrame
 from pyproj import CRS
 from shapely import (
+    Geometry,
     Polygon,
     Point,
     LineString,
     MultiLineString,
     MultiPolygon,
+    Point,
+    Polygon,
     polygonize_full,
 )
 
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Union
+
+
+from .base import RasHdf
+from .utils import (
+    convert_ras_hdf_string,
+    convert_ras_hdf_value,
+    get_first_hdf_group,
+    hdf5_attrs_to_dict,
+)
+
+
+class RasGeomHdfError(Exception):
+    """HEC-RAS Plan HDF error class."""
+
+    pass
 
 
 class RasGeomHdf(RasHdf):
@@ -30,6 +40,12 @@ class RasGeomHdf(RasHdf):
     GEOM_PATH = "Geometry"
     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"
+    BREAKLINES_PATH = f"{GEOM_PATH}/2D Flow Area Break Lines"
+    REFERENCE_LINES_PATH = f"{GEOM_PATH}/Reference Lines"
+    REFERENCE_POINTS_PATH = f"{GEOM_PATH}/Reference Points"
+    CROSS_SECTIONS = f"{GEOM_PATH}/Cross Sections"
+    RIVER_CENTERLINES = f"{GEOM_PATH}/River Centerlines"
 
     def __init__(self, name: str, **kwargs):
         """Open a HEC-RAS Geometry HDF file.
@@ -262,6 +278,38 @@ class RasGeomHdf(RasHdf):
 
         return d2_flow_area_attrs
 
+    def _get_polylines(
+        self,
+        path: str,
+        info_name: str = "Polyline Info",
+        parts_name: str = "Polyline Parts",
+        points_name: str = "Polyline Points",
+    ) -> List[Geometry]:
+        polyline_info_path = f"{path}/{info_name}"
+        polyline_parts_path = f"{path}/{parts_name}"
+        polyline_points_path = f"{path}/{points_name}"
+
+        polyline_info = self[polyline_info_path][()]
+        polyline_parts = self[polyline_parts_path][()]
+        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
+                        )
+                    )
+                )
+        return geoms
+
     def bc_lines(self) -> GeoDataFrame:
         """Return 2D mesh area boundary condition lines.
 
@@ -270,35 +318,15 @@ class RasGeomHdf(RasHdf):
         GeoDataFrame
             A GeoDataFrame containing the 2D mesh area boundary condition lines if they exist.
         """
-        if "/Geometry/Boundary Condition Lines" not in self:
+        if self.BC_LINES_PATH not in self:
             return GeoDataFrame()
-        bc_line_data = self["/Geometry/Boundary Condition Lines"]
+        bc_line_data = self[self.BC_LINES_PATH]
         bc_line_ids = range(bc_line_data["Attributes"][()].shape[0])
         v_conv_str = np.vectorize(convert_ras_hdf_string)
         names = v_conv_str(bc_line_data["Attributes"][()]["Name"])
         mesh_names = v_conv_str(bc_line_data["Attributes"][()]["SA-2D"])
         types = v_conv_str(bc_line_data["Attributes"][()]["Type"])
-        geoms = list()
-        for pnt_start, pnt_cnt, part_start, part_cnt in bc_line_data["Polyline Info"][
-            ()
-        ]:
-            points = bc_line_data["Polyline Points"][()][
-                pnt_start : pnt_start + pnt_cnt
-            ]
-            if part_cnt == 1:
-                geoms.append(LineString(points))
-            else:
-                parts = bc_line_data["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
-                        )
-                    )
-                )
+        geoms = self._get_polylines(self.BC_LINES_PATH)
         return GeoDataFrame(
             {
                 "bc_line_id": bc_line_ids,
@@ -319,34 +347,14 @@ class RasGeomHdf(RasHdf):
         GeoDataFrame
             A GeoDataFrame containing the 2D mesh area breaklines if they exist.
         """
-        if "/Geometry/2D Flow Area Break Lines" not in self:
+        if self.BREAKLINES_PATH not in self:
             return GeoDataFrame()
-        bl_line_data = self["/Geometry/2D Flow Area Break Lines"]
+        bl_line_data = self[self.BREAKLINES_PATH]
         bl_line_ids = range(bl_line_data["Attributes"][()].shape[0])
         names = np.vectorize(convert_ras_hdf_string)(
             bl_line_data["Attributes"][()]["Name"]
         )
-        geoms = list()
-        for pnt_start, pnt_cnt, part_start, part_cnt in bl_line_data["Polyline Info"][
-            ()
-        ]:
-            points = bl_line_data["Polyline Points"][()][
-                pnt_start : pnt_start + pnt_cnt
-            ]
-            if part_cnt == 1:
-                geoms.append(LineString(points))
-            else:
-                parts = bl_line_data["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
-                        )
-                    )
-                )
+        geoms = self._get_polylines(self.BREAKLINES_PATH)
         return GeoDataFrame(
             {"bl_id": bl_line_ids, "name": names, "geometry": geoms},
             geometry="geometry",
@@ -400,36 +408,21 @@ class RasGeomHdf(RasHdf):
         GeoDataFrame
             A GeoDataFrame containing the model structures if they exist.
         """
-        if "/Geometry/Structures" not in self:
+        if self.GEOM_STRUCTURES_PATH not in self:
             return GeoDataFrame()
-        struct_data = self["/Geometry/Structures"]
+        struct_data = self[self.GEOM_STRUCTURES_PATH]
         v_conv_val = np.vectorize(convert_ras_hdf_value)
         sd_attrs = struct_data["Attributes"][()]
         struct_dict = {"struct_id": range(sd_attrs.shape[0])}
         struct_dict.update(
             {name: v_conv_val(sd_attrs[name]) for name in sd_attrs.dtype.names}
         )
-        geoms = list()
-        for pnt_start, pnt_cnt, part_start, part_cnt in struct_data["Centerline Info"][
-            ()
-        ]:
-            points = struct_data["Centerline Points"][()][
-                pnt_start : pnt_start + pnt_cnt
-            ]
-            if part_cnt == 1:
-                geoms.append(LineString(points))
-            else:
-                parts = struct_data["Centerline 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
-                        )
-                    )
-                )
+        geoms = self._get_polylines(
+            self.GEOM_STRUCTURES_PATH,
+            info_name="Centerline Info",
+            parts_name="Centerline Parts",
+            points_name="Centerline Points",
+        )
         struct_gdf = GeoDataFrame(
             struct_dict,
             geometry=geoms,
@@ -447,11 +440,153 @@ class RasGeomHdf(RasHdf):
     def ic_points(self) -> GeoDataFrame:  # noqa D102
         raise NotImplementedError
 
-    def reference_lines(self) -> GeoDataFrame:  # noqa D102
-        raise NotImplementedError
+    def _reference_lines_points_names(
+        self, reftype: str = "lines", mesh_name: Optional[str] = None
+    ) -> Union[Dict[str, List[str]], List[str]]:
+        """Return reference line names.
 
-    def reference_points(self) -> GeoDataFrame:  # noqa D102
-        raise NotImplementedError
+        If a mesh name is provided, return a list of the reference line names for that mesh area.
+        If no mesh name is provided, return a dictionary of mesh names and their reference line names.
+
+        Parameters
+        ----------
+        mesh_name : str, optional
+            The name of the mesh area for which to return reference line names.
+
+        Returns
+        -------
+        Union[Dict[str, List[str]], List[str]]
+            A dictionary of mesh names and their reference line names if mesh_name is None.
+            A list of reference line names for the specified mesh area if mesh_name is not None.
+        """
+        if reftype == "lines":
+            path = self.REFERENCE_LINES_PATH
+            sa_2d_field = "SA-2D"
+        elif reftype == "points":
+            path = self.REFERENCE_POINTS_PATH
+            sa_2d_field = "SA/2D"
+        else:
+            raise RasGeomHdfError(
+                f"Invalid reference type: {reftype} -- must be 'lines' or 'points'."
+            )
+        attributes_path = f"{path}/Attributes"
+        if mesh_name is None and attributes_path not in self:
+            return {m: [] for m in self.mesh_area_names()}
+        if mesh_name is not None and attributes_path not in self:
+            return []
+        attributes = self[attributes_path][()]
+        v_conv_str = np.vectorize(convert_ras_hdf_string)
+        names = np.vectorize(convert_ras_hdf_string)(attributes["Name"])
+        if mesh_name is not None:
+            return names[v_conv_str(attributes[sa_2d_field]) == mesh_name].tolist()
+        mesh_names = np.vectorize(convert_ras_hdf_string)(attributes[sa_2d_field])
+        return {m: names[mesh_names == m].tolist() for m in np.unique(mesh_names)}
+
+    def reference_lines_names(
+        self, mesh_name: Optional[str] = None
+    ) -> Union[Dict[str, List[str]], List[str]]:
+        """Return reference line names.
+
+        If a mesh name is provided, return a list of the reference line names for that mesh area.
+        If no mesh name is provided, return a dictionary of mesh names and their reference line names.
+
+        Parameters
+        ----------
+        mesh_name : str, optional
+            The name of the mesh area for which to return reference line names.
+
+        Returns
+        -------
+        Union[Dict[str, List[str]], List[str]]
+            A dictionary of mesh names and their reference line names if mesh_name is None.
+            A list of reference line names for the specified mesh area if mesh_name is not None.
+        """
+        return self._reference_lines_points_names("lines", mesh_name)
+
+    def reference_points_names(
+        self, mesh_name: Optional[str] = None
+    ) -> Union[Dict[str, List[str]], List[str]]:
+        """Return reference point names.
+
+        If a mesh name is provided, return a list of the reference point names for that mesh area.
+        If no mesh name is provided, return a dictionary of mesh names and their reference point names.
+
+        Parameters
+        ----------
+        mesh_name : str, optional
+            The name of the mesh area for which to return reference point names.
+
+        Returns
+        -------
+        Union[Dict[str, List[str]], List[str]]
+            A dictionary of mesh names and their reference point names if mesh_name is None.
+            A list of reference point names for the specified mesh area if mesh_name is not None.
+        """
+        return self._reference_lines_points_names("points", mesh_name)
+
+    def reference_lines(self) -> GeoDataFrame:
+        """Return the reference lines geometry and attributes.
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the reference lines if they exist.
+        """
+        attributes_path = f"{self.REFERENCE_LINES_PATH}/Attributes"
+        if attributes_path not in self:
+            return GeoDataFrame()
+        attributes = self[attributes_path][()]
+        refline_ids = range(attributes.shape[0])
+        v_conv_str = np.vectorize(convert_ras_hdf_string)
+        names = v_conv_str(attributes["Name"])
+        mesh_names = v_conv_str(attributes["SA-2D"])
+        try:
+            types = v_conv_str(attributes["Type"])
+        except ValueError:
+            # "Type" field doesn't exist -- observed in some RAS HDF files
+            types = np.array([""] * attributes.shape[0])
+        geoms = self._get_polylines(self.REFERENCE_LINES_PATH)
+        return GeoDataFrame(
+            {
+                "refln_id": refline_ids,
+                "refln_name": names,
+                "mesh_name": mesh_names,
+                "type": types,
+                "geometry": geoms,
+            },
+            geometry="geometry",
+            crs=self.projection(),
+        )
+
+    def reference_points(self) -> GeoDataFrame:
+        """Return the reference points geometry and attributes.
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the reference points if they exist.
+        """
+        attributes_path = f"{self.REFERENCE_POINTS_PATH}/Attributes"
+        if attributes_path not in self:
+            return GeoDataFrame()
+        ref_points_group = self[self.REFERENCE_POINTS_PATH]
+        attributes = ref_points_group["Attributes"][:]
+        v_conv_str = np.vectorize(convert_ras_hdf_string)
+        names = v_conv_str(attributes["Name"])
+        mesh_names = v_conv_str(attributes["SA/2D"])
+        cell_id = attributes["Cell Index"]
+        points = ref_points_group["Points"][()]
+        return GeoDataFrame(
+            {
+                "refpt_id": range(attributes.shape[0]),
+                "refpt_name": names,
+                "mesh_name": mesh_names,
+                "cell_id": cell_id,
+                "geometry": list(map(Point, points)),
+            },
+            geometry="geometry",
+            crs=self.projection(),
+        )
 
     def pump_stations(self) -> GeoDataFrame:  # noqa D102
         raise NotImplementedError
@@ -465,11 +600,66 @@ class RasGeomHdf(RasHdf):
     def terrain_modifications(self) -> GeoDataFrame:  # noqa D102
         raise NotImplementedError
 
-    def cross_sections(self) -> GeoDataFrame:  # noqa D102
-        raise NotImplementedError
+    def cross_sections(self, datetime_to_str: bool = False) -> GeoDataFrame:
+        """Return the model 1D cross sections.
 
-    def river_reaches(self) -> GeoDataFrame:  # noqa D102
-        raise NotImplementedError
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the model 1D cross sections if they exist.
+        """
+        if self.CROSS_SECTIONS not in self:
+            return GeoDataFrame()
+
+        xs_data = self[self.CROSS_SECTIONS]
+        v_conv_val = np.vectorize(convert_ras_hdf_value)
+        xs_attrs = xs_data["Attributes"][()]
+        xs_dict = {"xs_id": range(xs_attrs.shape[0])}
+        xs_dict.update(
+            {name: v_conv_val(xs_attrs[name]) for name in xs_attrs.dtype.names}
+        )
+        geoms = self._get_polylines(self.CROSS_SECTIONS)
+        xs_gdf = GeoDataFrame(
+            xs_dict,
+            geometry=geoms,
+            crs=self.projection(),
+        )
+        if datetime_to_str:
+            xs_gdf["Last Edited"] = xs_gdf["Last Edited"].apply(
+                lambda x: pd.Timestamp.isoformat(x)
+            )
+        return xs_gdf
+
+    def river_reaches(self, datetime_to_str: bool = False) -> GeoDataFrame:
+        """Return the model 1D river reach lines.
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the model 1D river reach lines if they exist.
+        """
+        if self.RIVER_CENTERLINES not in self:
+            return GeoDataFrame()
+
+        river_data = self[self.RIVER_CENTERLINES]
+        v_conv_val = np.vectorize(convert_ras_hdf_value)
+        river_attrs = river_data["Attributes"][()]
+        river_dict = {"river_id": range(river_attrs.shape[0])}
+        river_dict.update(
+            {name: v_conv_val(river_attrs[name]) for name in river_attrs.dtype.names}
+        )
+        geoms = list()
+        geoms = self._get_polylines(self.RIVER_CENTERLINES)
+        river_gdf = GeoDataFrame(
+            river_dict,
+            geometry=geoms,
+            crs=self.projection(),
+        )
+        if datetime_to_str:
+            river_gdf["Last Edited"] = river_gdf["Last Edited"].apply(
+                lambda x: pd.Timestamp.isoformat(x)
+            )
+        return river_gdf
 
     def flowpaths(self) -> GeoDataFrame:  # noqa D102
         raise NotImplementedError
@@ -488,3 +678,33 @@ class RasGeomHdf(RasHdf):
 
     def blocked_obstructions(self) -> GeoDataFrame:  # noqa D102
         raise NotImplementedError
+
+    def cross_sections_elevations(self, round_to: int = 2) -> pd.DataFrame:
+        """Return the model cross section elevation information.
+
+        Returns
+        -------
+        DataFrame
+            A DataFrame containing the model cross section elevation information if they exist.
+        """
+        path = "/Geometry/Cross Sections"
+        if path not in self:
+            return pd.DataFrame()
+
+        xselev_data = self[path]
+        xs_df = self.cross_sections()
+        elevations = list()
+        for part_start, part_cnt in xselev_data["Station Elevation Info"][()]:
+            xzdata = xselev_data["Station Elevation Values"][()][
+                part_start : part_start + part_cnt
+            ]
+            elevations.append(xzdata)
+
+        xs_elev_df = xs_df[
+            ["xs_id", "River", "Reach", "RS", "Left Bank", "Right Bank"]
+        ].copy()
+        xs_elev_df["Left Bank"] = xs_elev_df["Left Bank"].round(round_to).astype(str)
+        xs_elev_df["Right Bank"] = xs_elev_df["Right Bank"].round(round_to).astype(str)
+        xs_elev_df["elevation info"] = elevations
+
+        return xs_elev_df