rashdf 0.1.0__py3-none-any.whl

rashdf/__init__.py

@@ -0,0 +1,5 @@
+from .base import RasHdf
+from .geom import RasGeomHdf
+from .plan import RasPlanHdf
+
+__all__ = ["RasHdf", "RasGeomHdf", "RasPlanHdf"]

rashdf/base.py

@@ -0,0 +1,78 @@
+import h5py
+from .utils import hdf5_attrs_to_dict
+from typing import Dict
+
+
+class RasHdf(h5py.File):
+    """Base class for reading RAS HDF files."""
+
+    def __init__(self, name: str, **kwargs):
+        """Open a HEC-RAS HDF file.
+
+        Parameters
+        ----------
+        name : str
+            The path to the RAS HDF file.
+        kwargs : dict
+            Additional keyword arguments to pass to h5py.File
+        """
+        super().__init__(name, mode="r", **kwargs)
+
+    @classmethod
+    def open_uri(
+        cls, uri: str, fsspec_kwargs: dict = {}, h5py_kwargs: dict = {}
+    ) -> "RasHdf":
+        """Open a HEC-RAS HDF file from a URI.
+
+        Parameters
+        ----------
+        uri : str
+            The URI of the RAS HDF file. Note this should be a path
+            recognized by fsspec, such as an S3 path or a Google Cloud
+            Storage path. See https://filesystem-spec.readthedocs.io/en/latest/api.html#fsspec.open
+        fsspec_kwargs : dict
+            Additional keyword arguments to pass to fsspec.open
+        h5py_kwargs : dict
+            Additional keyword arguments to pass to h5py.File
+
+        Returns
+        -------
+        RasHdf
+            The RAS HDF file opened from the URI.
+
+        Examples
+        --------
+        >>> results_hdf = RasHdf.open_uri("s3://my-bucket/results.hdf")
+        """
+        import fsspec
+
+        remote_file = fsspec.open(uri, mode="rb", **fsspec_kwargs)
+        return cls(remote_file.open(), **h5py_kwargs)
+
+    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.
+
+        Parameters
+        ----------
+            attr_path (str): The path within the HEC-RAS HDF file where the desired attributes are located (Ex. "Plan Data/Plan Parameters").
+
+        Returns
+        -------
+            plan_attrs (dict): Dictionary filled with attributes at given path, if attributes exist at that path.
+        """
+        attr_object = self.get(attr_path)
+
+        if attr_object:
+            return hdf5_attrs_to_dict(attr_object.attrs)
+
+        return {}
+
+    def get_root_attrs(self):
+        """Returns attributes at root level of HEC-RAS HDF file.
+
+        Returns
+        -------
+        dict
+            Dictionary filled with HEC-RAS HDF root attributes.
+        """
+        return self.get_attrs("/")

rashdf/geom.py

@@ -0,0 +1,416 @@
+from .base import RasHdf
+from .utils import convert_ras_hdf_string, get_first_hdf_group, hdf5_attrs_to_dict
+
+import numpy as np
+from geopandas import GeoDataFrame
+from pyproj import CRS
+from shapely import (
+    Polygon,
+    Point,
+    LineString,
+    MultiLineString,
+    MultiPolygon,
+    polygonize,
+)
+
+from typing import List, Optional
+
+
+class RasGeomHdf(RasHdf):
+    GEOM_PATH = "Geometry"
+    GEOM_STRUCTURES_PATH = f"{GEOM_PATH}/Structures"
+    FLOW_AREA_2D_PATH = f"{GEOM_PATH}/2D Flow Areas"
+
+    def __init__(self, name: str, **kwargs):
+        super().__init__(name, **kwargs)
+
+    def projection(self) -> Optional[CRS]:
+        """Return the projection of the RAS geometry as a
+        pyproj.CRS object.
+
+        Returns
+        -------
+        CRS
+            The projection of the RAS geometry.
+        """
+        proj_wkt = self.attrs.get("Projection")
+        if proj_wkt is None:
+            return None
+        if isinstance(proj_wkt, bytes) or isinstance(proj_wkt, np.bytes_):
+            proj_wkt = proj_wkt.decode("utf-8")
+        return CRS.from_wkt(proj_wkt)
+
+    def mesh_area_names(self) -> List[str]:
+        """Return a list of the 2D mesh area names of
+        the RAS geometry.
+
+        Returns
+        -------
+        list
+            A list of the 2D mesh area names (str) within the RAS geometry if 2D areas exist.
+        """
+        if "/Geometry/2D Flow Areas" not in self:
+            return list()
+        return list(
+            [
+                convert_ras_hdf_string(n)
+                for n in self["/Geometry/2D Flow Areas/Attributes"][()]["Name"]
+            ]
+        )
+
+    def mesh_areas(self) -> GeoDataFrame:
+        """Return 2D flow area perimeter polygons.
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the 2D flow area perimeter polygons if 2D areas exist.
+        """
+        mesh_area_names = self.mesh_area_names()
+        if not mesh_area_names:
+            return GeoDataFrame()
+        mesh_area_polygons = [
+            Polygon(self[f"/Geometry/2D Flow Areas/{n}/Perimeter"][()])
+            for n in mesh_area_names
+        ]
+        return GeoDataFrame(
+            {"mesh_name": mesh_area_names, "geometry": mesh_area_polygons},
+            geometry="geometry",
+            crs=self.projection(),
+        )
+
+    def mesh_cell_polygons(self) -> GeoDataFrame:
+        """Return the 2D flow mesh cell polygons.
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the 2D flow mesh cell polygons if 2D areas exist.
+        """
+        mesh_area_names = self.mesh_area_names()
+        if not mesh_area_names:
+            return GeoDataFrame()
+
+        face_gdf = self.mesh_cell_faces()
+
+        cell_dict = {"mesh_name": [], "cell_id": [], "geometry": []}
+        for i, mesh_name in enumerate(mesh_area_names):
+            cell_cnt = self["/Geometry/2D Flow Areas/Cell Info"][()][i][1]
+            cell_ids = list(range(cell_cnt))
+            cell_face_info = self[
+                f"/Geometry/2D Flow Areas/{mesh_name}/Cells Face and Orientation Info"
+            ][()]
+            cell_face_values = self[
+                f"/Geometry/2D Flow Areas/{mesh_name}/Cells Face and Orientation Values"
+            ][()][:, 0]
+            face_id_lists = list(
+                np.vectorize(
+                    lambda cell_id: str(
+                        cell_face_values[
+                            cell_face_info[cell_id][0] : cell_face_info[cell_id][0]
+                            + cell_face_info[cell_id][1]
+                        ]
+                    )
+                )(cell_ids)
+            )
+            mesh_faces = (
+                face_gdf[face_gdf.mesh_name == mesh_name][["face_id", "geometry"]]
+                .set_index("face_id")
+                .to_numpy()
+            )
+            cell_dict["mesh_name"] += [mesh_name] * cell_cnt
+            cell_dict["cell_id"] += cell_ids
+            cell_dict["geometry"] += list(
+                np.vectorize(
+                    lambda face_id_list: polygonize(
+                        np.ravel(
+                            mesh_faces[
+                                np.array(face_id_list.strip("[]").split()).astype(int)
+                            ]
+                        )
+                    ).geoms[0]
+                )(face_id_lists)
+            )
+        return GeoDataFrame(cell_dict, geometry="geometry", crs=self.projection())
+
+    def mesh_cell_points(self) -> GeoDataFrame:
+        """Return the 2D flow mesh cell points.
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the 2D flow mesh cell points if 2D areas exist.
+        """
+        mesh_area_names = self.mesh_area_names()
+        if not mesh_area_names:
+            return GeoDataFrame()
+        pnt_dict = {"mesh_name": [], "cell_id": [], "geometry": []}
+        for i, mesh_name in enumerate(mesh_area_names):
+            starting_row, count = self["/Geometry/2D Flow Areas/Cell Info"][()][i]
+            cell_pnt_coords = self["/Geometry/2D Flow Areas/Cell Points"][()][
+                starting_row : starting_row + count
+            ]
+            pnt_dict["mesh_name"] += [mesh_name] * cell_pnt_coords.shape[0]
+            pnt_dict["cell_id"] += range(count)
+            pnt_dict["geometry"] += list(
+                np.vectorize(lambda coords: Point(coords), signature="(n)->()")(
+                    cell_pnt_coords
+                )
+            )
+        return GeoDataFrame(pnt_dict, geometry="geometry", crs=self.projection())
+
+    def mesh_cell_faces(self) -> GeoDataFrame:
+        """Return the 2D flow mesh cell faces.
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the 2D flow mesh cell faces if 2D areas exist.
+        """
+        mesh_area_names = self.mesh_area_names()
+        if not mesh_area_names:
+            return GeoDataFrame()
+        face_dict = {"mesh_name": [], "face_id": [], "geometry": []}
+        for mesh_name in mesh_area_names:
+            facepoints_index = self[
+                f"/Geometry/2D Flow Areas/{mesh_name}/Faces FacePoint Indexes"
+            ][()]
+            facepoints_coordinates = self[
+                f"/Geometry/2D Flow Areas/{mesh_name}/FacePoints Coordinate"
+            ][()]
+            faces_perimeter_info = self[
+                f"/Geometry/2D Flow Areas/{mesh_name}/Faces Perimeter Info"
+            ][()]
+            faces_perimeter_values = self[
+                f"/Geometry/2D Flow Areas/{mesh_name}/Faces Perimeter Values"
+            ][()]
+            face_id = -1
+            for pnt_a_index, pnt_b_index in facepoints_index:
+                face_id += 1
+                face_dict["mesh_name"].append(mesh_name)
+                face_dict["face_id"].append(face_id)
+                coordinates = list()
+                coordinates.append(facepoints_coordinates[pnt_a_index])
+                starting_row, count = faces_perimeter_info[face_id]
+                if count > 0:
+                    coordinates += list(
+                        faces_perimeter_values[starting_row : starting_row + count]
+                    )
+                coordinates.append(facepoints_coordinates[pnt_b_index])
+                face_dict["geometry"].append(LineString(coordinates))
+        return GeoDataFrame(face_dict, geometry="geometry", crs=self.projection())
+
+    def get_geom_attrs(self):
+        """Returns base geometry attributes from a HEC-RAS HDF file.
+
+        Returns
+        -------
+        dict
+            Dictionary filled with base geometry attributes.
+        """
+        return self.get_attrs(self.GEOM_PATH)
+
+    def get_geom_structures_attrs(self):
+        """Returns geometry structures attributes from a HEC-RAS HDF file.
+
+        Returns
+        -------
+        dict
+            Dictionary filled with geometry structures attributes.
+        """
+        return self.get_attrs(self.GEOM_STRUCTURES_PATH)
+
+    def get_geom_2d_flow_area_attrs(self):
+        """Returns geometry 2d flow area attributes from a HEC-RAS HDF file.
+
+        Returns
+        -------
+        dict
+            Dictionary filled with geometry 2d flow area attributes.
+        """
+        try:
+            d2_flow_area = get_first_hdf_group(self.get(self.FLOW_AREA_2D_PATH))
+        except AttributeError:
+            raise AttributeError(
+                f"Unable to get 2D Flow Area; {self.FLOW_AREA_2D_PATH} group not found in HDF5 file."
+            )
+
+        d2_flow_area_attrs = hdf5_attrs_to_dict(d2_flow_area.attrs)
+
+        return d2_flow_area_attrs
+
+    def bc_lines(self) -> GeoDataFrame:
+        """Return the 2D mesh area boundary condition lines.
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the 2D mesh area boundary condition lines if they exist.
+        """
+        if "/Geometry/Boundary Condition Lines" not in self:
+            return GeoDataFrame()
+        bc_line_data = self["/Geometry/Boundary Condition Lines"]
+        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
+                        )
+                    )
+                )
+        return GeoDataFrame(
+            {
+                "bc_line_id": bc_line_ids,
+                "name": names,
+                "mesh_name": mesh_names,
+                "type": types,
+                "geometry": geoms,
+            },
+            geometry="geometry",
+            crs=self.projection(),
+        )
+
+    def breaklines(self) -> GeoDataFrame:
+        """Return the 2D mesh area breaklines.
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the 2D mesh area breaklines if they exist.
+        """
+        if "/Geometry/2D Flow Area Break Lines" not in self:
+            return GeoDataFrame()
+        bl_line_data = self["/Geometry/2D Flow Area Break Lines"]
+        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
+                        )
+                    )
+                )
+        return GeoDataFrame(
+            {"bl_id": bl_line_ids, "name": names, "geometry": geoms},
+            geometry="geometry",
+            crs=self.projection(),
+        )
+
+    def refinement_regions(self) -> GeoDataFrame:
+        """Return the 2D mesh area refinement regions.
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the 2D mesh area refinement regions if they exist.
+        """
+        if "/Geometry/2D Flow Area Refinement Regions" not in self:
+            return GeoDataFrame()
+        rr_data = self["/Geometry/2D Flow Area Refinement Regions"]
+        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
+                        )
+                    )
+                )
+        return GeoDataFrame(
+            {"rr_id": rr_ids, "name": names, "geometry": geoms},
+            geometry="geometry",
+            crs=self.projection(),
+        )
+
+    def connections(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def ic_points(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def reference_lines(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def reference_points(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def structures(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def pump_stations(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def mannings_calibration_regions(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def classification_polygons(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def terrain_modifications(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def cross_sections(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def river_reaches(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def flowpaths(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def bank_points(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def bank_lines(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def ineffective_areas(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def ineffective_points(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def blocked_obstructions(self) -> GeoDataFrame:
+        raise NotImplementedError

rashdf/plan.py

@@ -0,0 +1,78 @@
+from .geom import RasGeomHdf
+from typing import Dict
+from geopandas import GeoDataFrame
+
+
+class RasPlanHdf(RasGeomHdf):
+    PLAN_INFO_PATH = "Plan Data/Plan Information"
+    PLAN_PARAMS_PATH = "Plan Data/Plan Parameters"
+    PRECIP_PATH = "Event Conditions/Meteorology/Precipitation"
+    RESULTS_UNSTEADY_PATH = "Results/Unsteady"
+    RESULTS_UNSTEADY_SUMMARY_PATH = f"{RESULTS_UNSTEADY_PATH}/Summary"
+    VOLUME_ACCOUNTING_PATH = f"{RESULTS_UNSTEADY_PATH}/Volume Accounting"
+
+    def __init__(self, name: str, **kwargs):
+        super().__init__(name, **kwargs)
+
+    def get_plan_info_attrs(self) -> Dict:
+        """Returns plan information attributes from a HEC-RAS HDF plan file.
+
+        Returns
+        -------
+        dict
+            Dictionary filled with plan information attributes.
+        """
+        return self.get_attrs(self.PLAN_INFO_PATH)
+
+    def get_plan_param_attrs(self) -> Dict:
+        """Returns plan parameter attributes from a HEC-RAS HDF plan file.
+
+        Returns
+        -------
+        dict
+            Dictionary filled with plan parameter attributes.
+        """
+        return self.get_attrs(self.PLAN_PARAMS_PATH)
+
+    def get_meteorology_precip_attrs(self) -> Dict:
+        """Returns precipitation attributes from a HEC-RAS HDF plan file.
+
+        Returns
+        -------
+        dict
+            Dictionary filled with precipitation attributes.
+        """
+        return self.get_attrs(self.PRECIP_PATH)
+
+    def get_results_unsteady_attrs(self) -> Dict:
+        """Returns unsteady attributes from a HEC-RAS HDF plan file.
+
+        Returns
+        -------
+        dict
+            Dictionary filled with unsteady attributes.
+        """
+        return self.get_attrs(self.RESULTS_UNSTEADY_PATH)
+
+    def get_results_unsteady_summary_attrs(self) -> Dict:
+        """Returns results unsteady summary attributes from a HEC-RAS HDF plan file.
+
+        Returns
+        -------
+        dict
+            Dictionary filled with results summary attributes.
+        """
+        return self.get_attrs(self.RESULTS_UNSTEADY_SUMMARY_PATH)
+
+    def get_results_volume_accounting_attrs(self) -> Dict:
+        """Returns volume accounting attributes from a HEC-RAS HDF plan file.
+
+        Returns
+        -------
+        dict
+            Dictionary filled with volume accounting attributes.
+        """
+        return self.get_attrs(self.VOLUME_ACCOUNTING_PATH)
+
+    def enroachment_points(self) -> GeoDataFrame:
+        raise NotImplementedError

rashdf/utils.py

@@ -0,0 +1,215 @@
+import numpy as np
+import h5py
+from typing import Any, List, Tuple, Union, Optional
+
+from datetime import datetime, timedelta
+import re
+
+
+def parse_ras_datetime(datetime_str: str) -> datetime:
+    """Parse a datetime string from a RAS file into a datetime object.
+
+    Parameters
+    ----------
+        datetime_str (str): The datetime string to be parsed. The string should be in the format "ddMMMyyyy HHmm".
+
+    Returns
+    -------
+        datetime: A datetime object representing the parsed datetime.
+    """
+    format = "%d%b%Y %H:%M:%S"
+    return datetime.strptime(datetime_str, format)
+
+
+def parse_ras_simulation_window_datetime(datetime_str) -> datetime:
+    """
+    Parse a datetime string from a RAS simulation window into a datetime object.
+
+    Parameters
+    ----------
+        datetime_str: The datetime string to be parsed.
+
+    Returns
+    -------
+        datetime: A datetime object representing the parsed datetime.
+    """
+    format = "%d%b%Y %H%M"
+    return datetime.strptime(datetime_str, format)
+
+
+def parse_run_time_window(window: str) -> Tuple[datetime, datetime]:
+    """
+    Parse a run time window string into a tuple of datetime objects.
+
+    Parameters
+    ----------
+        window (str): The run time window string to be parsed.
+
+    Returns
+    -------
+        Tuple[datetime, datetime]: A tuple containing two datetime objects representing the start and end of the run
+        time window.
+    """
+    split = window.split(" to ")
+    begin = parse_ras_datetime(split[0])
+    end = parse_ras_datetime(split[1])
+    return begin, end
+
+
+def parse_duration(duration_str: str) -> timedelta:
+    """
+    Parse a duration string into a timedelta object.
+
+    Parameters
+    ----------
+        duration_str (str): The duration string to be parsed. The string should be in the format "HH:MM:SS".
+
+    Returns
+    -------
+        timedelta: A timedelta object representing the parsed duration.
+    """
+    hours, minutes, seconds = map(int, duration_str.split(":"))
+    duration = timedelta(hours=hours, minutes=minutes, seconds=seconds)
+    return duration
+
+
+def convert_ras_hdf_string(value: str) -> Union[bool, str, List[str]]:
+    """Convert a string value from an HEC-RAS HDF file into a Python object.
+
+    This function handles several specific string formats:
+    - "True" and "False" are converted to boolean values.
+    - Strings matching the format "ddMMMyyyy HH:mm:ss" or "ddMMMyyyy HHmm" are parsed into datetime objects.
+    - Strings matching the format "ddMMMyyyy HH:mm:ss to ddMMMyyyy HH:mm:ss" or "ddMMMyyyy HHmm to ddMMMyyyy HHmm"
+    are parsed into a list of two datetime objects.
+
+    Parameters
+    ----------
+        value (str): The string value to be converted.
+
+    Returns
+    -------
+        The converted value, which could be a boolean, a datetime string, a list of datetime strings, or the original
+        string if no other conditions are met.
+    """
+    ras_datetime_format1_re = r"\d{2}\w{3}\d{4} \d{2}:\d{2}:\d{2}"
+    ras_datetime_format2_re = r"\d{2}\w{3}\d{4} \d{2}\d{2}"
+    s = value.decode("utf-8")
+    if s == "True":
+        return True
+    elif s == "False":
+        return False
+    elif re.match(rf"^{ras_datetime_format1_re}", s):
+        if re.match(rf"^{ras_datetime_format1_re} to {ras_datetime_format1_re}$", s):
+            split = s.split(" to ")
+            return [
+                parse_ras_datetime(split[0]),
+                parse_ras_datetime(split[1]),
+            ]
+        return parse_ras_datetime(s)
+    elif re.match(rf"^{ras_datetime_format2_re}", s):
+        if re.match(rf"^{ras_datetime_format2_re} to {ras_datetime_format2_re}$", s):
+            split = s.split(" to ")
+            return [
+                parse_ras_simulation_window_datetime(split[0]),
+                parse_ras_simulation_window_datetime(split[1]),
+            ]
+        return parse_ras_simulation_window_datetime(s)
+    return s
+
+
+def convert_ras_hdf_value(
+    value: Any,
+) -> Union[None, bool, str, List[str], int, float, List[int], List[float]]:
+    """Convert a value from a HEC-RAS HDF file into a Python object.
+
+    This function handles several specific types:
+    - NaN values are converted to None.
+    - Byte strings are converted using the `convert_ras_hdf_string` function.
+    - NumPy integer or float types are converted to Python int or float.
+    - Regular ints and floats are left as they are.
+    - Lists, tuples, and NumPy arrays are recursively processed.
+    - All other types are converted to string.
+
+    Parameters
+    ----------
+        value (Any): The value to be converted.
+
+    Returns
+    -------
+        The converted value, which could be None, a boolean, a string, a list of strings, an integer, a float, a list
+        of integers, a list of floats, or the original value as a string if no other conditions are met.
+    """
+    # TODO (?): handle "8-bit bitfield" values in 2D Flow Area groups
+
+    # Check for NaN (np.nan)
+    if isinstance(value, np.floating) and np.isnan(value):
+        return None
+
+    # Check for byte strings
+    elif isinstance(value, bytes) or isinstance(value, np.bytes_):
+        return convert_ras_hdf_string(value)
+
+    # Check for NumPy integer or float types
+    elif isinstance(value, np.integer):
+        return int(value)
+    elif isinstance(value, np.floating):
+        return float(value)
+
+    # Leave regular ints and floats as they are
+    elif isinstance(value, (int, float)):
+        return value
+
+    elif isinstance(value, (list, tuple, np.ndarray)):
+        if len(value) > 1:
+            return [convert_ras_hdf_value(v) for v in value]
+        else:
+            return convert_ras_hdf_value(value[0])
+
+    # Convert all other types to string
+    else:
+        return str(value)
+
+
+def hdf5_attrs_to_dict(attrs: dict, prefix: str = None) -> dict:
+    """
+    Convert a dictionary of attributes from an HDF5 file into a Python dictionary.
+
+    Parameters:
+    ----------
+        attrs (dict): The attributes to be converted.
+        prefix (str, optional): An optional prefix to prepend to the keys.
+
+    Returns:
+    ----------
+        dict: A dictionary with the converted attributes.
+    """
+    results = {}
+    for k, v in attrs.items():
+        value = convert_ras_hdf_value(v)
+        if prefix:
+            key = f"{prefix}:{k}"
+        else:
+            key = k
+        results[key] = value
+    return results
+
+
+def get_first_hdf_group(parent_group: h5py.Group) -> Optional[h5py.Group]:
+    """
+    Get the first HDF5 group from a parent group.
+
+    This function iterates over the items in the parent group and returns the first item that is an instance of
+     h5py.Group. If no such item is found, it returns None.
+
+    Parameters:
+    ----------
+        parent_group (h5py.Group): The parent group to search in.
+
+    Returns:
+    ----------
+        Optional[h5py.Group]: The first HDF5 group in the parent group, or None if no group is found.
+    """
+    for _, item in parent_group.items():
+        if isinstance(item, h5py.Group):
+            return item
+    return None

rashdf-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 fema-ffrd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rashdf-0.1.0.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.1
+Name: rashdf
+Version: 0.1.0
+Summary: Read data from HEC-RAS HDF files.
+Project-URL: repository, https://github.com/fema-ffrd/rashdf
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: h5py
+Requires-Dist: geopandas
+Provides-Extra: dev
+Requires-Dist: pre-commit ; extra == 'dev'
+Requires-Dist: ruff ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+
+# 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)
+[![Release](https://github.com/fema-ffrd/rashdf/actions/workflows/release.yml/badge.svg)](https://github.com/fema-ffrd/rashdf/actions/workflows/release.yml)
+[![PyPI version](https://badge.fury.io/py/rashdf.svg)](https://badge.fury.io/py/rashdf)
+
+Read data from [HEC-RAS](https://www.hec.usace.army.mil/software/hec-ras/) [HDF](https://github.com/HDFGroup/hdf5) files.
+
+*Pronunciation: `raz·aitch·dee·eff`*
+
+## Install
+```bash
+$ pip install rashdf
+```
+
+## Usage
+`RasGeomHdf` and `RasPlanHdf` are extensions of
+[h5py.File](https://docs.h5py.org/en/stable/high/file.html#h5py.File). They contain
+methods to export HEC-RAS model geometry as
+[GeoDataFrame](https://geopandas.org/en/stable/docs/reference/geodataframe.html)
+objects.
+```python
+>>> from rashdf import RasGeomHdf
+>>> geom_hdf = RasGeomHdf("path/to/rasmodel/Muncie.g04.hdf")
+>>> mesh_cells = geom_hdf.mesh_cell_polygons()  # export a GeoDataFrame
+>>> mesh_cells
+             mesh_name  cell_id                                           geometry
+0     2D Interior Area        0  POLYGON ((406025.000 1805015.237, 406025.000 1...
+1     2D Interior Area        1  POLYGON ((406075.000 1805018.545, 406075.000 1...
+2     2D Interior Area        2  POLYGON ((406075.000 1804975.000, 406075.000 1...
+3     2D Interior Area        3  POLYGON ((406125.000 1804975.000, 406125.000 1...
+4     2D Interior Area        4  POLYGON ((406175.000 1804975.000, 406175.000 1...
+...                ...      ...                                                ...
+5386  2D Interior Area     5386  POLYGON ((409163.402 1802463.621, 409175.000 1...
+5387  2D Interior Area     5387  POLYGON ((409160.953 1802374.120, 409125.000 1...
+5388  2D Interior Area     5388  POLYGON ((409163.402 1802463.621, 409161.906 1...
+5389  2D Interior Area     5389  POLYGON ((409112.480 1802410.114, 409112.046 1...
+5390  2D Interior Area     5390  POLYGON ((409112.480 1802410.114, 409063.039 1...
+>>> mesh_cells.to_file("mucie-mesh-cell-polygons.shp")
+```
+
+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
+{'Computation Time DSS': '00:00:00', 'Computation Time Total': '00:00:23', 'Maximum WSEL Error': 0.0099277812987566, 'Maximum number of cores': 6, 'Run Time Window': [datetime.datetime(2024, 3, 27, 9, 31, 52), datetime.datetime(2024, 3, 27, 9, 32, 15)], 'Solution': 'Unsteady Finished Successfully', 'Time Solution Went Unstable': None, 'Time Stamp Solution Went Unstable': 'Not Applicable'}
+```
+
+## Documentation
+Coming soon.
+
+## Developer Setup
+Create a virtual environment in the project directory:
+```
+$ python -m venv venv-rashdf
+```
+
+Activate the virtual environment:
+```
+$ source ./venv/bin/activate
+(venv-rashdf) $
+```
+
+Install dev dependencies:
+```
+(venv-rashdf) $ pip install ".[dev]"
+```
+
+Install git hook scripts (used for automatic liniting/formatting)
+```
+(venv-rashdf) $ pre-commit install
+```
+
+With the virtual environment activated, run the tests:
+```
+(venv-rashdf) $ pytest
+```
+
+

rashdf-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+rashdf/__init__.py,sha256=r_UaNbJve1yWg-2r7qFiZVMdYiq4m5LNoRLJKL4HYYk,133
+rashdf/base.py,sha256=yTihpXoSm-S6kb1BGdru4UPIR3_-mDFrcEaQfXd8ujY,2384
+rashdf/geom.py,sha256=74VKwlgElFc167hTk2BbyFmKbbzi3o9SyW9tkH23XDM,14846
+rashdf/plan.py,sha256=GU8BlRBN27R-letDhF_fOK1xAaJsL4CSYEyBCiDBaPs,2472
+rashdf/utils.py,sha256=5jWSjCkPdnwGXwN7ELv9rpiUWtn3cprlZkfxmJYAWf8,7038
+rashdf-0.1.0.dist-info/LICENSE,sha256=L_0QaLpQVHPcglVjiaJPnOocwzP8uXevDRjUPr9DL1Y,1065
+rashdf-0.1.0.dist-info/METADATA,sha256=dFe6XNXj3PaygLZoSZ8DVM-M10vsrfP2drZZ0PaFBXw,4156
+rashdf-0.1.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+rashdf-0.1.0.dist-info/top_level.txt,sha256=1iE403K85UTilumVhhghg2JdH3ABHE-2DmvFpKvi9fA,7
+rashdf-0.1.0.dist-info/RECORD,,

rashdf-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

rashdf-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+rashdf