rashdf 0.1.0b1__py3-none-any.whl

rashdf/__init__.py

@@ -0,0 +1,3 @@
+from .base import RasHdf
+from .geom import RasGeomHdf
+from .plan import RasPlanHdf

rashdf/base.py

@@ -0,0 +1,45 @@
+import h5py
+
+
+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)

rashdf/geom.py

@@ -0,0 +1,202 @@
+from .base import RasHdf
+from .utils import convert_ras_hdf_string
+
+import numpy as np
+import pandas as pd
+from geopandas import GeoDataFrame
+from pyproj import CRS
+from shapely import Polygon, Point, LineString, polygonize
+
+from typing import Optional
+
+
+class RasGeomHdf(RasHdf):
+
+    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 type(proj_wkt) == bytes or type(proj_wkt) == np.bytes_:
+            proj_wkt = proj_wkt.decode("utf-8")
+        return CRS.from_wkt(proj_wkt)
+    
+    def mesh_area_names(self) -> list:
+        """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 bc_lines(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def breaklines(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    def refinement_regions(self) -> GeoDataFrame:
+        raise NotImplementedError
+
+    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,9 @@
+from .geom import RasGeomHdf
+
+from geopandas import GeoDataFrame
+
+
+class RasPlanHdf(RasGeomHdf):
+
+    def enroachment_points(self) -> GeoDataFrame:
+        raise NotImplementedError

rashdf/utils.py

@@ -0,0 +1,170 @@
+import numpy as np
+
+from typing import Any, List, Tuple, Union
+
+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)

rashdf-0.1.0b1.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.0b1.dist-info/METADATA

@@ -0,0 +1,41 @@
+Metadata-Version: 2.1
+Name: rashdf
+Version: 0.1.0b1
+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: pytest ; extra == 'dev'
+
+# rashdf
+Read data from HEC-RAS HDF files.
+
+## Setup
+Create a virtual environment in the project directory:
+```
+$ python -m venv venv-rashdf
+```
+
+Activate the virtual environment:
+```
+$ source ./venv/bin/activate
+(venv-rashdf) $
+```
+
+With the virtual environment activated, run the tests:
+```
+(venv-rashdf) $ pytest
+```
+
+

rashdf-0.1.0b1.dist-info/RECORD

@@ -0,0 +1,10 @@
+rashdf/__init__.py,sha256=BC8nMo8C99kkSp_yJOtfRr9fZKaelZ5SSxHDGgu7j9E,83
+rashdf/base.py,sha256=_mmY1s6z_CtPpJJMyV7m_k-E9yb1QPpxW1oEdGifRZ4,1421
+rashdf/geom.py,sha256=m7JmFFGo4Sw2PcLTdxSaHWH4X4GRcpQvuz_tHswGpTA,7909
+rashdf/plan.py,sha256=ASY3FmBV2UfxG9_WmEhPH2-C6rL-ULIFZbnRVd-kiOI,182
+rashdf/utils.py,sha256=L1BLTilxAvb-TcYY02PWwfeTJoskT8EUEaRb64pvCFg,5715
+rashdf-0.1.0b1.dist-info/LICENSE,sha256=L_0QaLpQVHPcglVjiaJPnOocwzP8uXevDRjUPr9DL1Y,1065
+rashdf-0.1.0b1.dist-info/METADATA,sha256=2-D-23ddlBBxzW0Bfs0r_psw_3oMcO0DAUk8vHPSbXw,1034
+rashdf-0.1.0b1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+rashdf-0.1.0b1.dist-info/top_level.txt,sha256=1iE403K85UTilumVhhghg2JdH3ABHE-2DmvFpKvi9fA,7
+rashdf-0.1.0b1.dist-info/RECORD,,

rashdf-0.1.0b1.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.0b1.dist-info/top_level.txt

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