rashdf 0.8.2__py3-none-any.whl → 0.8.3__py3-none-any.whl

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/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/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/utils.py

@@ -42,14 +42,14 @@ def parse_ras_datetime(datetime_str: str) -> datetime:
     -------
         datetime: A datetime object representing the parsed datetime.
     """
-    format = "%d%b%Y %H:%M:%S"
+    datetime_format = "%d%b%Y %H:%M:%S"
 
     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 = 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
 
@@ -68,14 +68,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
 
@@ -190,8 +190,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

{rashdf-0.8.2.dist-info → rashdf-0.8.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rashdf
-Version: 0.8.2
+Version: 0.8.3
 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.3.dist-info/RECORD

@@ -0,0 +1,12 @@
+cli.py,sha256=NtO1bHaiM8GBW5Gv9eSF8Iu-ekwTIQAfV_hd7DBXyLQ,6834
+rashdf/__init__.py,sha256=XXFtJDgLPCimqAhfsFz_pTWYECJiRT0i-Kb1uflXmVU,156
+rashdf/base.py,sha256=cAQJX1aeBJKb3MJ06ltpbRTUaZX5NkuxpR1J4f7FyTU,2507
+rashdf/geom.py,sha256=O2PMYY7w7fdW2U4u0rsbWeEDKAmsUh4-49ro-xUMc4A,28755
+rashdf/plan.py,sha256=ctkfLBqocF2TpU6wYygXkxE2voCJa8WyVGYlimsyxS4,63612
+rashdf/utils.py,sha256=AihMVcxxaufAnOVT3e5ollD5UINI_kjxSHohBS77-l0,10879
+rashdf-0.8.3.dist-info/licenses/LICENSE,sha256=L_0QaLpQVHPcglVjiaJPnOocwzP8uXevDRjUPr9DL1Y,1065
+rashdf-0.8.3.dist-info/METADATA,sha256=myhrp-erERbBWyofdiUaJLgC1apyviBizGBHMyGhRak,6072
+rashdf-0.8.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rashdf-0.8.3.dist-info/entry_points.txt,sha256=LHHMR1lLy4wRyscMuW1RlYDXemtPgqQhNcILz0DtStY,36
+rashdf-0.8.3.dist-info/top_level.txt,sha256=SrmLb6FFTJtM_t6O1v0M0JePshiQJMHr0yYVkHL7ztk,11
+rashdf-0.8.3.dist-info/RECORD,,

rashdf-0.8.2.dist-info/RECORD

@@ -1,12 +0,0 @@
-cli.py,sha256=HbyrdUVKfrmtU2T9ljKTPQ-ugomJqYbCA26ghGJDJh0,6588
-rashdf/__init__.py,sha256=XXFtJDgLPCimqAhfsFz_pTWYECJiRT0i-Kb1uflXmVU,156
-rashdf/base.py,sha256=cAQJX1aeBJKb3MJ06ltpbRTUaZX5NkuxpR1J4f7FyTU,2507
-rashdf/geom.py,sha256=ODdqxcK152AcBAYCw-gcvsmGRxhch7wvzN11YuDzz6Q,28495
-rashdf/plan.py,sha256=d8YhpC6cV8rhh3qf1o12TbhUvo_4pMh75vIdDkcAvjE,63971
-rashdf/utils.py,sha256=Cba6sULF0m0jg6CQass4bPm2oxTd_avoe1pRQxq082c,10896
-rashdf-0.8.2.dist-info/licenses/LICENSE,sha256=L_0QaLpQVHPcglVjiaJPnOocwzP8uXevDRjUPr9DL1Y,1065
-rashdf-0.8.2.dist-info/METADATA,sha256=wtCbEs_hvNJ9MfbAoLkmtulhTEv34tTlxP3r5BT7xrE,6072
-rashdf-0.8.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rashdf-0.8.2.dist-info/entry_points.txt,sha256=LHHMR1lLy4wRyscMuW1RlYDXemtPgqQhNcILz0DtStY,36
-rashdf-0.8.2.dist-info/top_level.txt,sha256=SrmLb6FFTJtM_t6O1v0M0JePshiQJMHr0yYVkHL7ztk,11
-rashdf-0.8.2.dist-info/RECORD,,