rashdf 0.8.2__tar.gz → 0.8.4__tar.gz

{rashdf-0.8.2 → rashdf-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rashdf
-Version: 0.8.2
+Version: 0.8.4
 Summary: Read data from HEC-RAS HDF files.
 Project-URL: repository, https://github.com/fema-ffrd/rashdf
 Classifier: Development Status :: 4 - Beta

{rashdf-0.8.2 → rashdf-0.8.4}/pyproject.toml

@@ -12,7 +12,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
 ]
-version = "0.8.2"
+version = "0.8.4"
 dependencies = ["h5py", "geopandas>=1.0,<2.0", "pyarrow", "xarray<=2025.4.0"]
 
 [project.optional-dependencies]

{rashdf-0.8.2 → rashdf-0.8.4}/src/cli.py

@@ -88,12 +88,10 @@ def parse_args(args: str) -> argparse.Namespace:
         action="store_true",
         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",
@@ -142,62 +140,81 @@ def parse_args(args: str) -> argparse.Namespace:
     return args
 
 
-def export(args: argparse.Namespace) -> Optional[str]:
-    """Act on parsed arguments to extract data from HEC-RAS HDF files."""
+def _print_requested_drivers(args: argparse.Namespace) -> bool:
     if args.pyogrio_drivers:
         for driver in pyogrio_supported_drivers():
             print(driver)
-        return
+        return True
     if hasattr(args, "fiona_drivers") and args.fiona_drivers:
         for driver in fiona_supported_drivers():
             print(driver)
-        return
+        return True
+    return False
+
+
+def _load_hdf_class(args: argparse.Namespace):
     if re.match(r"^.*\.p\d\d\.hdf$", args.hdf_file):
         ras_hdf_class = RasPlanHdf
     else:
         ras_hdf_class = RasGeomHdf
+
     if re.match(r"^\w+://", args.hdf_file):
-        geom_hdf = ras_hdf_class.open_uri(args.hdf_file)
+        return ras_hdf_class.open_uri(args.hdf_file)
     else:
-        geom_hdf = ras_hdf_class(args.hdf_file)
+        return ras_hdf_class(args.hdf_file)
+
+
+def _print_stdout_geojson(gdf: GeoDataFrame, kwargs: dict) -> str:
+    # If an output file path isn't provided, write the GeoDataFrame to stdout
+    # as GeoJSON. Convert any datetime columns to strings.
+    gdf = df_datetimes_to_str(gdf)
+    with warnings.catch_warnings():
+        # Squash warnings about converting the CRS to OGC URN format.
+        # Likely to come up since USACE's Albers projection is a custom CRS.
+        # A warning written to stdout might cause issues with downstream processing.
+        warnings.filterwarnings(
+            "ignore",
+            (
+                "GeoDataFrame's CRS is not representable in URN OGC format."
+                " Resulting JSON will contain no CRS information."
+            ),
+        )
+        result = gdf.to_json(**kwargs)
+    print("No output file!")
+    print(result)
+    return result
+
+
+def _write_to_file(gdf: GeoDataFrame, args: argparse.Namespace, kwargs: dict):
+    output_file_path = Path(args.output_file)
+    output_file_ext = output_file_path.suffix
+    if output_file_ext not in [".gpkg"]:
+        # Unless the user specifies a format that supports datetime,
+        # convert any datetime columns to string.
+        gdf = df_datetimes_to_str(gdf)
+    gdf.to_file(args.output_file, engine=args.engine, **kwargs)
+
+
+def export(args: argparse.Namespace) -> Optional[str]:
+    """Act on parsed arguments to extract data from HEC-RAS HDF files."""
+    if _print_requested_drivers(args):
+        return
+
+    geom_hdf = _load_hdf_class(args)
     func = getattr(geom_hdf, args.func)
     gdf: GeoDataFrame = func()
     kwargs = literal_eval(args.kwargs) if args.kwargs else {}
     if args.to_crs:
         gdf = gdf.to_crs(args.to_crs)
     if not args.output_file:
-        # If an output file path isn't provided, write the GeoDataFrame to stdout
-        # as GeoJSON. Convert any datetime columns to strings.
-        gdf = df_datetimes_to_str(gdf)
-        with warnings.catch_warnings():
-            # Squash warnings about converting the CRS to OGC URN format.
-            # Likely to come up since USACE's Albers projection is a custom CRS.
-            # A warning written to stdout might cause issues with downstream processing.
-            warnings.filterwarnings(
-                "ignore",
-                (
-                    "GeoDataFrame's CRS is not representable in URN OGC format."
-                    " Resulting JSON will contain no CRS information."
-                ),
-            )
-            result = gdf.to_json(**kwargs)
-        print("No output file!")
-        print(result)
-        return result
+        return _print_stdout_geojson(gdf, kwargs)
     elif args.parquet:
         gdf.to_parquet(args.output_file, **kwargs)
         return
     elif args.feather:
         gdf.to_feather(args.output_file, **kwargs)
         return
-    output_file_path = Path(args.output_file)
-    output_file_ext = output_file_path.suffix
-    if output_file_ext not in [".gpkg"]:
-        # Unless the user specifies a format that supports datetime,
-        # 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, engine=args.engine, **kwargs)
+    _write_to_file(gdf, args, kwargs)
 
 
 def main():

{rashdf-0.8.2 → rashdf-0.8.4}/src/rashdf/geom.py

@@ -48,8 +48,11 @@ class RasGeomHdf(RasHdf):
     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"
+    CROSS_SECTIONS_PATH = f"{GEOM_PATH}/Cross Sections"
     RIVER_CENTERLINES = f"{GEOM_PATH}/River Centerlines"
+    SA_2D = "SA/2D"
+
+    LAST_EDITED_COLUMN = "Last Edited"
 
     def __init__(self, name: str, **kwargs):
         """Open a HEC-RAS Geometry HDF file.
@@ -87,13 +90,11 @@ class RasGeomHdf(RasHdf):
             A list of the 2D mesh area names (str) within the RAS geometry if 2D areas exist.
         """
         if self.FLOW_AREA_2D_PATH not in self:
-            return list()
-        return list(
-            [
-                convert_ras_hdf_string(n)
-                for n in self[f"{self.FLOW_AREA_2D_PATH}/Attributes"][()]["Name"]
-            ]
-        )
+            return []
+        return [
+            convert_ras_hdf_string(n)
+            for n in self[f"{self.FLOW_AREA_2D_PATH}/Attributes"][()]["Name"]
+        ]
 
     def mesh_areas(self) -> GeoDataFrame:
         """Return 2D flow area perimeter polygons.
@@ -147,7 +148,9 @@ class RasGeomHdf(RasHdf):
             ][()][:, 0]
             face_id_lists = list(
                 np.vectorize(
-                    lambda cell_id: str(
+                    lambda cell_id,
+                    cell_face_values=cell_face_values,
+                    cell_face_info=cell_face_info: str(
                         cell_face_values[
                             cell_face_info[cell_id][0] : cell_face_info[cell_id][0]
                             + cell_face_info[cell_id][1]
@@ -164,7 +167,7 @@ class RasGeomHdf(RasHdf):
             cell_dict["cell_id"] += cell_ids
             cell_dict["geometry"] += list(
                 np.vectorize(
-                    lambda face_id_list: (
+                    lambda face_id_list, mesh_faces=mesh_faces: (
                         lambda geom_col: Polygon((geom_col[0] or geom_col[3]).geoms[0])
                     )(
                         polygonize_full(
@@ -237,7 +240,7 @@ class RasGeomHdf(RasHdf):
                 face_id += 1
                 face_dict["mesh_name"].append(mesh_name)
                 face_dict["face_id"].append(face_id)
-                coordinates = list()
+                coordinates = []
                 coordinates.append(facepoints_coordinates[pnt_a_index])
                 starting_row, count = faces_perimeter_info[face_id]
                 if count > 0:
@@ -312,10 +315,10 @@ class RasGeomHdf(RasHdf):
                     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 (
@@ -392,7 +395,7 @@ class RasGeomHdf(RasHdf):
         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()
+        geoms = []
         for i, (pnt_start, pnt_cnt, part_start, part_cnt) in enumerate(
             rr_data["Polygon Info"][()]
         ):
@@ -406,10 +409,10 @@ class RasGeomHdf(RasHdf):
                     ]
                     geoms.append(
                         MultiPolygon(
-                            list(
+                            [
                                 points[part_pnt_start : part_pnt_start + part_pnt_cnt]
                                 for part_pnt_start, part_pnt_cnt in parts
-                            )
+                            ]
                         )
                     )
             except (
@@ -463,9 +466,9 @@ class RasGeomHdf(RasHdf):
             crs=self.projection(),
         )
         if datetime_to_str:
-            struct_gdf["Last Edited"] = struct_gdf["Last Edited"].apply(
-                lambda x: pd.Timestamp.isoformat(x)
-            )
+            struct_gdf[self.LAST_EDITED_COLUMN] = struct_gdf[
+                self.LAST_EDITED_COLUMN
+            ].apply(lambda x: pd.Timestamp.isoformat(x))
         return struct_gdf
 
     def connections(self) -> GeoDataFrame:  # noqa D102
@@ -484,7 +487,7 @@ class RasGeomHdf(RasHdf):
         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"])
+        mesh_names = v_conv_str(ic_data["Attributes"][()][self.SA_2D])
         cell_ids = ic_data["Attributes"][()]["Cell Index"]
         points = ic_data["Points"][()]
         return GeoDataFrame(
@@ -523,7 +526,7 @@ class RasGeomHdf(RasHdf):
             sa_2d_field = "SA-2D"
         elif reftype == "points":
             path = self.REFERENCE_POINTS_PATH
-            sa_2d_field = "SA/2D"
+            sa_2d_field = self.SA_2D
         else:
             raise RasGeomHdfError(
                 f"Invalid reference type: {reftype} -- must be 'lines' or 'points'."
@@ -632,7 +635,7 @@ class RasGeomHdf(RasHdf):
         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"])
+        mesh_names = v_conv_str(attributes[self.SA_2D])
         cell_id = attributes["Cell Index"]
         points = ref_points_group["Points"][()]
         return GeoDataFrame(
@@ -667,24 +670,24 @@ class RasGeomHdf(RasHdf):
         GeoDataFrame
             A GeoDataFrame containing the model 1D cross sections if they exist.
         """
-        if self.CROSS_SECTIONS not in self:
+        xs_attribute_path = self.CROSS_SECTIONS_PATH + "/Attributes"
+        if xs_attribute_path not in self:
             return GeoDataFrame()
 
-        xs_data = self[self.CROSS_SECTIONS]
+        xs_attrs = self[xs_attribute_path][()]
         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)
+        geoms = self._get_polylines(self.CROSS_SECTIONS_PATH)
         xs_gdf = GeoDataFrame(
             xs_dict,
             geometry=geoms,
             crs=self.projection(),
         )
         if datetime_to_str:
-            xs_gdf["Last Edited"] = xs_gdf["Last Edited"].apply(
+            xs_gdf[self.LAST_EDITED_COLUMN] = xs_gdf[self.LAST_EDITED_COLUMN].apply(
                 lambda x: pd.Timestamp.isoformat(x)
             )
         return xs_gdf
@@ -707,7 +710,6 @@ class RasGeomHdf(RasHdf):
         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,
@@ -715,9 +717,9 @@ class RasGeomHdf(RasHdf):
             crs=self.projection(),
         )
         if datetime_to_str:
-            river_gdf["Last Edited"] = river_gdf["Last Edited"].apply(
-                lambda x: pd.Timestamp.isoformat(x)
-            )
+            river_gdf[self.LAST_EDITED_COLUMN] = river_gdf[
+                self.LAST_EDITED_COLUMN
+            ].apply(lambda x: pd.Timestamp.isoformat(x))
         return river_gdf
 
     def flowpaths(self) -> GeoDataFrame:  # noqa D102
@@ -752,18 +754,20 @@ class RasGeomHdf(RasHdf):
 
         xselev_data = self[path]
         xs_df = self.cross_sections()
-        elevations = list()
+        elevations = []
         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)
 
+        left_bank = "Left Bank"
+        right_bank = "Right Bank"
         xs_elev_df = xs_df[
-            ["xs_id", "River", "Reach", "RS", "Left Bank", "Right Bank"]
+            ["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[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

{rashdf-0.8.2 → rashdf-0.8.4}/src/rashdf/plan.py

@@ -20,6 +20,9 @@ from datetime import datetime
 from enum import Enum
 from typing import Dict, List, Optional, Tuple, Union
 
+# Shared constant
+WATER_SURFACE = "Water Surface"
+
 
 class RasPlanHdfError(Exception):
     """HEC-RAS Plan HDF error class."""
@@ -32,7 +35,7 @@ class XsSteadyOutputVar(Enum):
 
     ENERGY_GRADE = "Energy Grade"
     FLOW = "Flow"
-    WATER_SURFACE = "Water Surface"
+    WATER_SURFACE = WATER_SURFACE
     ENCROACHMENT_STATION_LEFT = "Encroachment Station Left"
     ENCROACHMENT_STATION_RIGHT = "Encroachment Station Right"
     AREA_INEFFECTIVE_TOTAL = "Area including Ineffective Total"
@@ -77,7 +80,7 @@ class TimeSeriesOutputVar(Enum):
     """Time series output variables."""
 
     # Default Outputs
-    WATER_SURFACE = "Water Surface"
+    WATER_SURFACE = WATER_SURFACE
     FACE_VELOCITY = "Face Velocity"
 
     # Optional Outputs
@@ -141,7 +144,6 @@ TIME_SERIES_OUTPUT_VARS_FACES = [
     TimeSeriesOutputVar.FACE_TANGENTIAL_VELOCITY,
     TimeSeriesOutputVar.FACE_VELOCITY,
     TimeSeriesOutputVar.FACE_WATER_SURFACE,
-    # TODO: investigate why "Face Wind Term" data gets written as a 1D array
     # TimeSeriesOutputVar.FACE_WIND_TERM,
 ]
 
@@ -178,6 +180,8 @@ class RasPlanHdf(RasGeomHdf):
     STEADY_XS_PATH = f"{STEADY_PROFILES_PATH}/Cross Sections"
     STEADY_XS_ADDITIONAL_PATH = f"{STEADY_XS_PATH}/Additional Variables"
 
+    INVALID_REFTYPE_ERROR = 'reftype must be either "lines" or "points".'
+
     def __init__(self, name: str, **kwargs):
         """Open a HEC-RAS Plan HDF file.
 
@@ -297,7 +301,7 @@ class RasPlanHdf(RasGeomHdf):
         self,
         mesh_name: str,
         var: SummaryOutputVar,
-        time_unit: str = "days",
+        time_unit: str = None,
         round_to: str = "0.1 s",
     ) -> np.ndarray[np.datetime64]:
         """Return an array of times for min/max summary output data.
@@ -321,7 +325,8 @@ class RasPlanHdf(RasGeomHdf):
         """
         start_time = self._simulation_start_time()
         max_ws_group = self._mesh_summary_output_group(mesh_name, var)
-        time_unit = self._summary_output_min_max_time_unit(max_ws_group)
+        if time_unit is None:
+            time_unit = self._summary_output_min_max_time_unit(max_ws_group)
         max_ws_raw = max_ws_group[:]
         max_ws_times_raw = max_ws_raw[1]
         # we get weirdly specific datetime values if we don't round to e.g., 0.1 seconds;
@@ -693,7 +698,7 @@ class RasPlanHdf(RasGeomHdf):
         """
         mesh_names_counts = self._2d_flow_area_names_and_counts()
         mesh_names = [mesh_name for mesh_name, _ in mesh_names_counts]
-        vars = set()
+        summary_vars = set()
         for mesh_name in mesh_names:
             path = f"{self.SUMMARY_OUTPUT_2D_FLOW_AREAS_PATH}/{mesh_name}"
             datasets = self[path].keys()
@@ -702,12 +707,12 @@ class RasPlanHdf(RasGeomHdf):
                     var = SummaryOutputVar(dataset)
                 except ValueError:
                     continue
-                vars.add(var)
+                summary_vars.add(var)
         if cells_or_faces == "cells":
-            vars = vars.intersection(SUMMARY_OUTPUT_VARS_CELLS)
+            summary_vars = summary_vars.intersection(SUMMARY_OUTPUT_VARS_CELLS)
         elif cells_or_faces == "faces":
-            vars = vars.intersection(SUMMARY_OUTPUT_VARS_FACES)
-        return sorted(list(vars), key=lambda x: x.value)
+            summary_vars = summary_vars.intersection(SUMMARY_OUTPUT_VARS_FACES)
+        return sorted(summary_vars, key=lambda x: x.value)
 
     def _mesh_summary_outputs_gdf(
         self,
@@ -894,7 +899,6 @@ class RasPlanHdf(RasGeomHdf):
         try:
             import dask.array as da
 
-            # TODO: user-specified chunks?
             values = da.from_array(group, chunks=group.chunks)
         except ImportError:
             values = group[:]
@@ -926,9 +930,7 @@ class RasPlanHdf(RasGeomHdf):
             An xarray DataArray with dimensions 'time' and 'cell_id'.
         """
         times = self.unsteady_datetimes()
-        mesh_names_counts = {
-            name: count for name, count in self._2d_flow_area_names_and_counts()
-        }
+        mesh_names_counts = dict(self._2d_flow_area_names_and_counts())
         if mesh_name not in mesh_names_counts:
             raise ValueError(f"Mesh '{mesh_name}' not found in the Plan HDF file.")
         if isinstance(var, str):
@@ -1067,7 +1069,7 @@ class RasPlanHdf(RasGeomHdf):
             output_path = self.REFERENCE_POINTS_OUTPUT_PATH
             abbrev = "refpt"
         else:
-            raise ValueError('reftype must be either "lines" or "points".')
+            raise ValueError(self.INVALID_REFTYPE_ERROR)
         reference_group = self.get(output_path)
         if reference_group is None:
             raise RasPlanHdfError(
@@ -1085,14 +1087,13 @@ class RasPlanHdf(RasGeomHdf):
         times = self.unsteady_datetimes()
 
         das = {}
-        for var in ["Flow", "Velocity", "Water Surface"]:
+        for var in ["Flow", "Velocity", WATER_SURFACE]:
             group = reference_group.get(var)
             if group is None:
                 continue
             try:
                 import dask.array as da
 
-                # TODO: user-specified chunks?
                 values = da.from_array(group, chunks=group.chunks)
             except ImportError:
                 values = group[:]
@@ -1147,7 +1148,6 @@ class RasPlanHdf(RasGeomHdf):
         try:
             import dask.array as da
 
-            # TODO: user-specified chunks?
             values = da.from_array(dataset, chunks=dataset.chunks)
         except ImportError:
             values = dataset[:]
@@ -1224,9 +1224,6 @@ class RasPlanHdf(RasGeomHdf):
                 f"Could not find HDF group at path '{output_path}'."
                 f" Does the Plan HDF file contain reference {vartype} output data?"
             )
-        if "Attributes" in observed_group.keys():
-            attr_path = observed_group["Attributes"]
-            attrs_df = pd.DataFrame(attr_path[:]).map(convert_ras_hdf_value)
 
         das = {}
         for idx, site in enumerate(observed_group.keys()):
@@ -1288,19 +1285,19 @@ class RasPlanHdf(RasGeomHdf):
         elif reftype == "points":
             abbrev = "refpt"
         else:
-            raise ValueError('reftype must be either "lines" or "points".')
+            raise ValueError(self.INVALID_REFTYPE_ERROR)
         ds = self.reference_timeseries_output(reftype=reftype)
         result = {
             f"{abbrev}_id": ds[f"{abbrev}_id"],
             f"{abbrev}_name": ds[f"{abbrev}_name"],
             "mesh_name": ds.mesh_name,
         }
-        vars = {
+        var_abbrevs = {
             "Flow": "q",
-            "Water Surface": "ws",
+            WATER_SURFACE: "ws",
             "Velocity": "v",
         }
-        for var, abbrev in vars.items():
+        for var, abbrev in var_abbrevs.items():
             if var not in ds:
                 continue
             max_var = ds[var].max(dim="time")
@@ -1326,7 +1323,7 @@ class RasPlanHdf(RasGeomHdf):
             abbrev = "refpt"
             gdf = super().reference_points()
         else:
-            raise ValueError('reftype must be either "lines" or "points".')
+            raise ValueError(self.INVALID_REFTYPE_ERROR)
         if include_output is False:
             return gdf
         summary_output = self.reference_summary_output(reftype=reftype)
@@ -1650,7 +1647,6 @@ class RasPlanHdf(RasGeomHdf):
             # and a bit risky because these private methods are more likely
             # to change, but short of reimplementing these functions ourselves
             # it's the best way to get the metadata we need.
-            # TODO: raise an issue in Kerchunk to expose this functionality?
             filters = SingleHdf5ToZarr._decode_filters(None, hdf_ds)
             encoding[var] = {"compressor": None, "filters": filters}
             storage_info = SingleHdf5ToZarr._storage_info(None, hdf_ds)

{rashdf-0.8.2 → rashdf-0.8.4}/src/rashdf/utils.py

@@ -10,6 +10,36 @@ from typing import Any, Callable, List, Tuple, Union, Optional
 import warnings
 
 
+def deprecated(func) -> Callable:
+    """
+    Deprecate a function.
+
+    This is a decorator which can be used to mark functions as deprecated.
+    It will result in a warning being emitted when the function is used.
+
+    Parameters
+    ----------
+        func: The function to be deprecated.
+
+    Returns
+    -------
+        The decorated function.
+    """
+
+    def new_func(*args, **kwargs):
+        warnings.warn(
+            f"{func.__name__} is deprecated and will be removed in a future version.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        return func(*args, **kwargs)
+
+    new_func.__name__ = func.__name__
+    new_func.__doc__ = func.__doc__
+    new_func.__dict__.update(func.__dict__)
+    return new_func
+
+
 def parse_ras_datetime_ms(datetime_str: str) -> datetime:
     """Parse a datetime string with milliseconds from a RAS file into a datetime object.
 
@@ -36,24 +66,37 @@ def parse_ras_datetime(datetime_str: str) -> datetime:
 
     Parameters
     ----------
-        datetime_str (str): The datetime string to be parsed. The string should be in the format "ddMMMyyyy HH:mm:ss".
+        datetime_str (str): The datetime string to be parsed.
 
     Returns
     -------
         datetime: A datetime object representing the parsed datetime.
     """
-    format = "%d%b%Y %H:%M:%S"
+    date_formats = ["%d%b%Y", "%m/%d/%Y", "%m-%d-%Y", "%Y/%m/%d", "%Y-%m-%d"]
+    time_formats = ["%H:%M:%S", "%H%M"]
+    datetime_formats = [
+        f"{date} {time}" for date in date_formats for time in time_formats
+    ]
 
-    if datetime_str.endswith("24:00:00"):
-        datetime_str = datetime_str.replace("24:00:00", "00:00:00")
-        parsed_dt = datetime.strptime(datetime_str, format)
-        parsed_dt += timedelta(days=1)
-    else:
-        parsed_dt = datetime.strptime(datetime_str, format)
+    is_2400 = datetime_str.endswith((" 24:00:00", " 2400", " 24:00"))
+    if is_2400:
+        datetime_str = datetime_str.split()[0] + " 00:00:00"
 
-    return parsed_dt
+    last_exception = None
+    for fmt in datetime_formats:
+        try:
+            parsed_dt = datetime.strptime(datetime_str, fmt)
+            if is_2400:
+                parsed_dt += timedelta(days=1)
+            return parsed_dt
+        except ValueError as e:
+            last_exception = e
+            continue
+
+    raise ValueError(f"Invalid date format: {datetime_str}") from last_exception
 
 
+@deprecated
 def parse_ras_simulation_window_datetime(datetime_str) -> datetime:
     """
     Parse a datetime string from a RAS simulation window into a datetime object.
@@ -68,14 +111,14 @@ def parse_ras_simulation_window_datetime(datetime_str) -> datetime:
     -------
         datetime: A datetime object representing the parsed datetime.
     """
-    format = "%d%b%Y %H%M"
+    datetime_format = "%d%b%Y %H%M"
 
     if datetime_str.endswith("2400"):
         datetime_str = datetime_str.replace("2400", "0000")
-        parsed_dt = datetime.strptime(datetime_str, format)
+        parsed_dt = datetime.strptime(datetime_str, datetime_format)
         parsed_dt += timedelta(days=1)
     else:
-        parsed_dt = datetime.strptime(datetime_str, format)
+        parsed_dt = datetime.strptime(datetime_str, datetime_format)
 
     return parsed_dt
 
@@ -139,32 +182,37 @@ def convert_ras_hdf_string(
         a list of datetime strings, a timedelta objects, 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}"
     ras_duration_format_re = r"\d{2}:\d{2}:\d{2}"
+    date_patterns_re = [
+        r"\d{2}\w{3}\d{4}",
+        r"\d{2}/\d{2}/\d{4}",
+        r"\d{2}-\d{2}-\d{4}",
+        r"\d{4}/\d{2}/\d{2}",
+        r"\d{4}-\d{2}-\d{2}",
+    ]
+    time_patterns_re = [
+        r"\d{2}:\d{2}:\d{2}",
+        r"\d{4}",
+    ]
+    datetime_patterns_re = [
+        f"{date} {time}" for date in date_patterns_re for time in time_patterns_re
+    ]
     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)
     elif re.match(rf"^{ras_duration_format_re}$", s):
         return parse_duration(s)
+    for dt_re in datetime_patterns_re:
+        if re.match(rf"^{dt_re}", s):
+            if re.match(rf"^{dt_re} to {dt_re}$", s):
+                start, end = s.split(" to ")
+                return [
+                    parse_ras_datetime(start),
+                    parse_ras_datetime(end),
+                ]
+            return parse_ras_datetime(s)
     return s
 
 
@@ -190,8 +238,6 @@ def convert_ras_hdf_value(
         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
@@ -308,33 +354,3 @@ def ras_timesteps_to_datetimes(
         start_time + pd.Timedelta(timestep, unit=time_unit).round(round_to)
         for timestep in timesteps.astype(np.float64)
     ]
-
-
-def deprecated(func) -> Callable:
-    """
-    Deprecate a function.
-
-    This is a decorator which can be used to mark functions as deprecated.
-    It will result in a warning being emitted when the function is used.
-
-    Parameters
-    ----------
-        func: The function to be deprecated.
-
-    Returns
-    -------
-        The decorated function.
-    """
-
-    def new_func(*args, **kwargs):
-        warnings.warn(
-            f"{func.__name__} is deprecated and will be removed in a future version.",
-            category=DeprecationWarning,
-            stacklevel=2,
-        )
-        return func(*args, **kwargs)
-
-    new_func.__name__ = func.__name__
-    new_func.__doc__ = func.__doc__
-    new_func.__dict__.update(func.__dict__)
-    return new_func

{rashdf-0.8.2 → rashdf-0.8.4}/src/rashdf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rashdf
-Version: 0.8.2
+Version: 0.8.4
 Summary: Read data from HEC-RAS HDF files.
 Project-URL: repository, https://github.com/fema-ffrd/rashdf
 Classifier: Development Status :: 4 - Beta

{rashdf-0.8.2 → rashdf-0.8.4}/tests/test_cli.py

@@ -4,6 +4,7 @@ from src.cli import (
     docstring_to_help,
     fiona_supported_drivers,
     pyogrio_supported_drivers,
+    _load_hdf_class,
 )
 
 import geopandas as gpd
@@ -13,6 +14,7 @@ import pytest
 import builtins
 import json
 from pathlib import Path
+from argparse import Namespace
 
 TEST_DATA = Path("./tests/data")
 MUNCIE_G05 = TEST_DATA / "ras/Muncie.g05.hdf"
@@ -168,3 +170,20 @@ def test_print_fiona_supported_drivers(capfd):
     assert "GeoJSON" in captured.out
     assert "GPKG" in captured.out
     assert "MBTiles" not in captured.out
+
+
+def test_load_hdf_class_remote_plan(monkeypatch):
+    import src.cli
+
+    fake_uri_path = "s3://some-bucket/BaldEagle.p18.hdf"
+    args = Namespace(hdf_file=fake_uri_path)
+
+    class MockRasPlanHdf:
+        def open_uri(path):
+            return Namespace(path=path)
+
+    # Replace RasPlanHdf with Mock so open_uri() works with fake path
+    monkeypatch.setattr(src.cli, "RasPlanHdf", MockRasPlanHdf)
+
+    geom_hdf = _load_hdf_class(args)
+    assert geom_hdf.path == fake_uri_path

{rashdf-0.8.2 → rashdf-0.8.4}/tests/test_plan.py

@@ -715,3 +715,21 @@ def test_encroachment_points():
             phdf.encroachment_points(profile_name="PF#2"),
             enc_pnts_json,
         )
+
+
+def test_invalid_reference_type_reference_timeseries_output():
+    with RasPlanHdf(BALD_EAGLE_P18) as phdf:
+        with pytest.raises(ValueError):
+            phdf.reference_timeseries_output(reftype="Not supported type")
+
+
+def test_invalid_group_reference_timeseries_output():
+    with RasPlanHdf(BALD_EAGLE_P18) as phdf:
+        with pytest.raises(RasPlanHdfError):
+            phdf.reference_timeseries_output()
+
+
+def test_invalid_group_reference_summary_output():
+    with RasPlanHdf(BALD_EAGLE_P18) as phdf:
+        with pytest.raises(ValueError):
+            phdf.reference_summary_output(reftype="Not supported type")

{rashdf-0.8.2 → rashdf-0.8.4}/tests/test_utils.py

@@ -35,7 +35,51 @@ def test_convert_ras_hdf_value():
     assert utils.convert_ras_hdf_value(b"15Mar2024 2315") == datetime(
         2024, 3, 15, 23, 15, 0
     )
-
+    assert utils.convert_ras_hdf_value(b"15Mar2024 2400") == datetime(
+        2024, 3, 16, 0, 0, 0
+    )
+    assert utils.convert_ras_hdf_value(b"03/15/2024 2400") == datetime(
+        2024, 3, 16, 0, 0, 0
+    )
+    assert utils.convert_ras_hdf_value(b"03-15-2024 2400") == datetime(
+        2024, 3, 16, 0, 0, 0
+    )
+    assert utils.convert_ras_hdf_value(b"2024/03/15 2400") == datetime(
+        2024, 3, 16, 0, 0, 0
+    )
+    assert utils.convert_ras_hdf_value(b"2024-03-15 2400") == datetime(
+        2024, 3, 16, 0, 0, 0
+    )
+    assert utils.convert_ras_hdf_value(b"15Mar2024 0000") == datetime(
+        2024, 3, 15, 0, 0, 0
+    )
+    assert utils.convert_ras_hdf_value(b"03/15/2024 0000") == datetime(
+        2024, 3, 15, 0, 0, 0
+    )
+    assert utils.convert_ras_hdf_value(b"03-15-2024 0000") == datetime(
+        2024, 3, 15, 0, 0, 0
+    )
+    assert utils.convert_ras_hdf_value(b"2024/03/15 0000") == datetime(
+        2024, 3, 15, 0, 0, 0
+    )
+    assert utils.convert_ras_hdf_value(b"2024-03-15 0000") == datetime(
+        2024, 3, 15, 0, 0, 0
+    )
+    assert utils.convert_ras_hdf_value(b"15Mar2024 23:59:59") == datetime(
+        2024, 3, 15, 23, 59, 59
+    )
+    assert utils.convert_ras_hdf_value(b"03/15/2024 23:59:59") == datetime(
+        2024, 3, 15, 23, 59, 59
+    )
+    assert utils.convert_ras_hdf_value(b"03-15-2024 23:59:59") == datetime(
+        2024, 3, 15, 23, 59, 59
+    )
+    assert utils.convert_ras_hdf_value(b"2024/03/15 23:59:59") == datetime(
+        2024, 3, 15, 23, 59, 59
+    )
+    assert utils.convert_ras_hdf_value(b"2024-03-15 23:59:59") == datetime(
+        2024, 3, 15, 23, 59, 59
+    )
     assert utils.convert_ras_hdf_value(b"15Mar2024 1639 to 16Mar2024 1639") == [
         datetime(2024, 3, 15, 16, 39, 0),
         datetime(2024, 3, 16, 16, 39, 0),