rashdf 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

cli.py

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

rashdf/base.py

@@ -19,6 +19,7 @@ class RasHdf(h5py.File):
             Additional keyword arguments to pass to h5py.File
         """
         super().__init__(name, mode="r", **kwargs)
+        self._loc = name
 
     @classmethod
     def open_uri(
@@ -49,7 +50,9 @@ class RasHdf(h5py.File):
         import fsspec
 
         remote_file = fsspec.open(uri, mode="rb", **fsspec_kwargs)
-        return cls(remote_file.open(), **h5py_kwargs)
+        result = cls(remote_file.open(), **h5py_kwargs)
+        result._loc = uri
+        return result
 
     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.

rashdf/geom.py

@@ -1,12 +1,13 @@
 """HEC-RAS Geometry HDF class."""
 
-from typing import Dict, List, Optional
-
 import numpy as np
 import pandas as pd
 from geopandas import GeoDataFrame
 from pyproj import CRS
 from shapely import (
+    Geometry,
+    Polygon,
+    Point,
     LineString,
     MultiLineString,
     MultiPolygon,
@@ -15,6 +16,9 @@ from shapely import (
     polygonize_full,
 )
 
+from typing import Dict, List, Optional, Union
+
+
 from .base import RasHdf
 from .utils import (
     convert_ras_hdf_string,
@@ -24,12 +28,24 @@ from .utils import (
 )
 
 
+class RasGeomHdfError(Exception):
+    """HEC-RAS Plan HDF error class."""
+
+    pass
+
+
 class RasGeomHdf(RasHdf):
     """HEC-RAS Geometry HDF class."""
 
     GEOM_PATH = "Geometry"
     GEOM_STRUCTURES_PATH = f"{GEOM_PATH}/Structures"
     FLOW_AREA_2D_PATH = f"{GEOM_PATH}/2D Flow Areas"
+    BC_LINES_PATH = f"{GEOM_PATH}/Boundary Condition Lines"
+    BREAKLINES_PATH = f"{GEOM_PATH}/2D Flow Area Break Lines"
+    REFERENCE_LINES_PATH = f"{GEOM_PATH}/Reference Lines"
+    REFERENCE_POINTS_PATH = f"{GEOM_PATH}/Reference Points"
+    CROSS_SECTIONS = f"{GEOM_PATH}/Cross Sections"
+    RIVER_CENTERLINES = f"{GEOM_PATH}/River Centerlines"
 
     def __init__(self, name: str, **kwargs):
         """Open a HEC-RAS Geometry HDF file.
@@ -262,6 +278,38 @@ class RasGeomHdf(RasHdf):
 
         return d2_flow_area_attrs
 
+    def _get_polylines(
+        self,
+        path: str,
+        info_name: str = "Polyline Info",
+        parts_name: str = "Polyline Parts",
+        points_name: str = "Polyline Points",
+    ) -> List[Geometry]:
+        polyline_info_path = f"{path}/{info_name}"
+        polyline_parts_path = f"{path}/{parts_name}"
+        polyline_points_path = f"{path}/{points_name}"
+
+        polyline_info = self[polyline_info_path][()]
+        polyline_parts = self[polyline_parts_path][()]
+        polyline_points = self[polyline_points_path][()]
+
+        geoms = []
+        for pnt_start, pnt_cnt, part_start, part_cnt in polyline_info:
+            points = polyline_points[pnt_start : pnt_start + pnt_cnt]
+            if part_cnt == 1:
+                geoms.append(LineString(points))
+            else:
+                parts = polyline_parts[part_start : part_start + part_cnt]
+                geoms.append(
+                    MultiLineString(
+                        list(
+                            points[part_pnt_start : part_pnt_start + part_pnt_cnt]
+                            for part_pnt_start, part_pnt_cnt in parts
+                        )
+                    )
+                )
+        return geoms
+
     def bc_lines(self) -> GeoDataFrame:
         """Return 2D mesh area boundary condition lines.
 
@@ -270,35 +318,15 @@ class RasGeomHdf(RasHdf):
         GeoDataFrame
             A GeoDataFrame containing the 2D mesh area boundary condition lines if they exist.
         """
-        if "/Geometry/Boundary Condition Lines" not in self:
+        if self.BC_LINES_PATH not in self:
             return GeoDataFrame()
-        bc_line_data = self["/Geometry/Boundary Condition Lines"]
+        bc_line_data = self[self.BC_LINES_PATH]
         bc_line_ids = range(bc_line_data["Attributes"][()].shape[0])
         v_conv_str = np.vectorize(convert_ras_hdf_string)
         names = v_conv_str(bc_line_data["Attributes"][()]["Name"])
         mesh_names = v_conv_str(bc_line_data["Attributes"][()]["SA-2D"])
         types = v_conv_str(bc_line_data["Attributes"][()]["Type"])
-        geoms = list()
-        for pnt_start, pnt_cnt, part_start, part_cnt in bc_line_data["Polyline Info"][
-            ()
-        ]:
-            points = bc_line_data["Polyline Points"][()][
-                pnt_start : pnt_start + pnt_cnt
-            ]
-            if part_cnt == 1:
-                geoms.append(LineString(points))
-            else:
-                parts = bc_line_data["Polyline Parts"][()][
-                    part_start : part_start + part_cnt
-                ]
-                geoms.append(
-                    MultiLineString(
-                        list(
-                            points[part_pnt_start : part_pnt_start + part_pnt_cnt]
-                            for part_pnt_start, part_pnt_cnt in parts
-                        )
-                    )
-                )
+        geoms = self._get_polylines(self.BC_LINES_PATH)
         return GeoDataFrame(
             {
                 "bc_line_id": bc_line_ids,
@@ -319,34 +347,14 @@ class RasGeomHdf(RasHdf):
         GeoDataFrame
             A GeoDataFrame containing the 2D mesh area breaklines if they exist.
         """
-        if "/Geometry/2D Flow Area Break Lines" not in self:
+        if self.BREAKLINES_PATH not in self:
             return GeoDataFrame()
-        bl_line_data = self["/Geometry/2D Flow Area Break Lines"]
+        bl_line_data = self[self.BREAKLINES_PATH]
         bl_line_ids = range(bl_line_data["Attributes"][()].shape[0])
         names = np.vectorize(convert_ras_hdf_string)(
             bl_line_data["Attributes"][()]["Name"]
         )
-        geoms = list()
-        for pnt_start, pnt_cnt, part_start, part_cnt in bl_line_data["Polyline Info"][
-            ()
-        ]:
-            points = bl_line_data["Polyline Points"][()][
-                pnt_start : pnt_start + pnt_cnt
-            ]
-            if part_cnt == 1:
-                geoms.append(LineString(points))
-            else:
-                parts = bl_line_data["Polyline Parts"][()][
-                    part_start : part_start + part_cnt
-                ]
-                geoms.append(
-                    MultiLineString(
-                        list(
-                            points[part_pnt_start : part_pnt_start + part_pnt_cnt]
-                            for part_pnt_start, part_pnt_cnt in parts
-                        )
-                    )
-                )
+        geoms = self._get_polylines(self.BREAKLINES_PATH)
         return GeoDataFrame(
             {"bl_id": bl_line_ids, "name": names, "geometry": geoms},
             geometry="geometry",
@@ -400,36 +408,21 @@ class RasGeomHdf(RasHdf):
         GeoDataFrame
             A GeoDataFrame containing the model structures if they exist.
         """
-        if "/Geometry/Structures" not in self:
+        if self.GEOM_STRUCTURES_PATH not in self:
             return GeoDataFrame()
-        struct_data = self["/Geometry/Structures"]
+        struct_data = self[self.GEOM_STRUCTURES_PATH]
         v_conv_val = np.vectorize(convert_ras_hdf_value)
         sd_attrs = struct_data["Attributes"][()]
         struct_dict = {"struct_id": range(sd_attrs.shape[0])}
         struct_dict.update(
             {name: v_conv_val(sd_attrs[name]) for name in sd_attrs.dtype.names}
         )
-        geoms = list()
-        for pnt_start, pnt_cnt, part_start, part_cnt in struct_data["Centerline Info"][
-            ()
-        ]:
-            points = struct_data["Centerline Points"][()][
-                pnt_start : pnt_start + pnt_cnt
-            ]
-            if part_cnt == 1:
-                geoms.append(LineString(points))
-            else:
-                parts = struct_data["Centerline Parts"][()][
-                    part_start : part_start + part_cnt
-                ]
-                geoms.append(
-                    MultiLineString(
-                        list(
-                            points[part_pnt_start : part_pnt_start + part_pnt_cnt]
-                            for part_pnt_start, part_pnt_cnt in parts
-                        )
-                    )
-                )
+        geoms = self._get_polylines(
+            self.GEOM_STRUCTURES_PATH,
+            info_name="Centerline Info",
+            parts_name="Centerline Parts",
+            points_name="Centerline Points",
+        )
         struct_gdf = GeoDataFrame(
             struct_dict,
             geometry=geoms,
@@ -447,11 +440,153 @@ class RasGeomHdf(RasHdf):
     def ic_points(self) -> GeoDataFrame:  # noqa D102
         raise NotImplementedError
 
-    def reference_lines(self) -> GeoDataFrame:  # noqa D102
-        raise NotImplementedError
+    def _reference_lines_points_names(
+        self, reftype: str = "lines", mesh_name: Optional[str] = None
+    ) -> Union[Dict[str, List[str]], List[str]]:
+        """Return reference line names.
 
-    def reference_points(self) -> GeoDataFrame:  # noqa D102
-        raise NotImplementedError
+        If a mesh name is provided, return a list of the reference line names for that mesh area.
+        If no mesh name is provided, return a dictionary of mesh names and their reference line names.
+
+        Parameters
+        ----------
+        mesh_name : str, optional
+            The name of the mesh area for which to return reference line names.
+
+        Returns
+        -------
+        Union[Dict[str, List[str]], List[str]]
+            A dictionary of mesh names and their reference line names if mesh_name is None.
+            A list of reference line names for the specified mesh area if mesh_name is not None.
+        """
+        if reftype == "lines":
+            path = self.REFERENCE_LINES_PATH
+            sa_2d_field = "SA-2D"
+        elif reftype == "points":
+            path = self.REFERENCE_POINTS_PATH
+            sa_2d_field = "SA/2D"
+        else:
+            raise RasGeomHdfError(
+                f"Invalid reference type: {reftype} -- must be 'lines' or 'points'."
+            )
+        attributes_path = f"{path}/Attributes"
+        if mesh_name is None and attributes_path not in self:
+            return {m: [] for m in self.mesh_area_names()}
+        if mesh_name is not None and attributes_path not in self:
+            return []
+        attributes = self[attributes_path][()]
+        v_conv_str = np.vectorize(convert_ras_hdf_string)
+        names = np.vectorize(convert_ras_hdf_string)(attributes["Name"])
+        if mesh_name is not None:
+            return names[v_conv_str(attributes[sa_2d_field]) == mesh_name].tolist()
+        mesh_names = np.vectorize(convert_ras_hdf_string)(attributes[sa_2d_field])
+        return {m: names[mesh_names == m].tolist() for m in np.unique(mesh_names)}
+
+    def reference_lines_names(
+        self, mesh_name: Optional[str] = None
+    ) -> Union[Dict[str, List[str]], List[str]]:
+        """Return reference line names.
+
+        If a mesh name is provided, return a list of the reference line names for that mesh area.
+        If no mesh name is provided, return a dictionary of mesh names and their reference line names.
+
+        Parameters
+        ----------
+        mesh_name : str, optional
+            The name of the mesh area for which to return reference line names.
+
+        Returns
+        -------
+        Union[Dict[str, List[str]], List[str]]
+            A dictionary of mesh names and their reference line names if mesh_name is None.
+            A list of reference line names for the specified mesh area if mesh_name is not None.
+        """
+        return self._reference_lines_points_names("lines", mesh_name)
+
+    def reference_points_names(
+        self, mesh_name: Optional[str] = None
+    ) -> Union[Dict[str, List[str]], List[str]]:
+        """Return reference point names.
+
+        If a mesh name is provided, return a list of the reference point names for that mesh area.
+        If no mesh name is provided, return a dictionary of mesh names and their reference point names.
+
+        Parameters
+        ----------
+        mesh_name : str, optional
+            The name of the mesh area for which to return reference point names.
+
+        Returns
+        -------
+        Union[Dict[str, List[str]], List[str]]
+            A dictionary of mesh names and their reference point names if mesh_name is None.
+            A list of reference point names for the specified mesh area if mesh_name is not None.
+        """
+        return self._reference_lines_points_names("points", mesh_name)
+
+    def reference_lines(self) -> GeoDataFrame:
+        """Return the reference lines geometry and attributes.
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the reference lines if they exist.
+        """
+        attributes_path = f"{self.REFERENCE_LINES_PATH}/Attributes"
+        if attributes_path not in self:
+            return GeoDataFrame()
+        attributes = self[attributes_path][()]
+        refline_ids = range(attributes.shape[0])
+        v_conv_str = np.vectorize(convert_ras_hdf_string)
+        names = v_conv_str(attributes["Name"])
+        mesh_names = v_conv_str(attributes["SA-2D"])
+        try:
+            types = v_conv_str(attributes["Type"])
+        except ValueError:
+            # "Type" field doesn't exist -- observed in some RAS HDF files
+            types = np.array([""] * attributes.shape[0])
+        geoms = self._get_polylines(self.REFERENCE_LINES_PATH)
+        return GeoDataFrame(
+            {
+                "refln_id": refline_ids,
+                "refln_name": names,
+                "mesh_name": mesh_names,
+                "type": types,
+                "geometry": geoms,
+            },
+            geometry="geometry",
+            crs=self.projection(),
+        )
+
+    def reference_points(self) -> GeoDataFrame:
+        """Return the reference points geometry and attributes.
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the reference points if they exist.
+        """
+        attributes_path = f"{self.REFERENCE_POINTS_PATH}/Attributes"
+        if attributes_path not in self:
+            return GeoDataFrame()
+        ref_points_group = self[self.REFERENCE_POINTS_PATH]
+        attributes = ref_points_group["Attributes"][:]
+        v_conv_str = np.vectorize(convert_ras_hdf_string)
+        names = v_conv_str(attributes["Name"])
+        mesh_names = v_conv_str(attributes["SA/2D"])
+        cell_id = attributes["Cell Index"]
+        points = ref_points_group["Points"][()]
+        return GeoDataFrame(
+            {
+                "refpt_id": range(attributes.shape[0]),
+                "refpt_name": names,
+                "mesh_name": mesh_names,
+                "cell_id": cell_id,
+                "geometry": list(map(Point, points)),
+            },
+            geometry="geometry",
+            crs=self.projection(),
+        )
 
     def pump_stations(self) -> GeoDataFrame:  # noqa D102
         raise NotImplementedError
@@ -473,33 +608,17 @@ class RasGeomHdf(RasHdf):
         GeoDataFrame
             A GeoDataFrame containing the model 1D cross sections if they exist.
         """
-        if "/Geometry/Cross Sections" not in self:
+        if self.CROSS_SECTIONS not in self:
             return GeoDataFrame()
 
-        xs_data = self["/Geometry/Cross Sections"]
+        xs_data = self[self.CROSS_SECTIONS]
         v_conv_val = np.vectorize(convert_ras_hdf_value)
         xs_attrs = xs_data["Attributes"][()]
         xs_dict = {"xs_id": range(xs_attrs.shape[0])}
         xs_dict.update(
             {name: v_conv_val(xs_attrs[name]) for name in xs_attrs.dtype.names}
         )
-        geoms = list()
-        for pnt_start, pnt_cnt, part_start, part_cnt in xs_data["Polyline Info"][()]:
-            points = xs_data["Polyline Points"][()][pnt_start : pnt_start + pnt_cnt]
-            if part_cnt == 1:
-                geoms.append(LineString(points))
-            else:
-                parts = xs_data["Polyline Parts"][()][
-                    part_start : part_start + part_cnt
-                ]
-                geoms.append(
-                    MultiLineString(
-                        list(
-                            points[part_pnt_start : part_pnt_start + part_pnt_cnt]
-                            for part_pnt_start, part_pnt_cnt in parts
-                        )
-                    )
-                )
+        geoms = self._get_polylines(self.CROSS_SECTIONS)
         xs_gdf = GeoDataFrame(
             xs_dict,
             geometry=geoms,
@@ -519,10 +638,10 @@ class RasGeomHdf(RasHdf):
         GeoDataFrame
             A GeoDataFrame containing the model 1D river reach lines if they exist.
         """
-        if "/Geometry/River Centerlines" not in self:
+        if self.RIVER_CENTERLINES not in self:
             return GeoDataFrame()
 
-        river_data = self["/Geometry/River Centerlines"]
+        river_data = self[self.RIVER_CENTERLINES]
         v_conv_val = np.vectorize(convert_ras_hdf_value)
         river_attrs = river_data["Attributes"][()]
         river_dict = {"river_id": range(river_attrs.shape[0])}
@@ -530,22 +649,7 @@ class RasGeomHdf(RasHdf):
             {name: v_conv_val(river_attrs[name]) for name in river_attrs.dtype.names}
         )
         geoms = list()
-        for pnt_start, pnt_cnt, part_start, part_cnt in river_data["Polyline Info"][()]:
-            points = river_data["Polyline Points"][()][pnt_start : pnt_start + pnt_cnt]
-            if part_cnt == 1:
-                geoms.append(LineString(points))
-            else:
-                parts = river_data["Polyline Parts"][()][
-                    part_start : part_start + part_cnt
-                ]
-                geoms.append(
-                    MultiLineString(
-                        list(
-                            points[part_pnt_start : part_pnt_start + part_pnt_cnt]
-                            for part_pnt_start, part_pnt_cnt in parts
-                        )
-                    )
-                )
+        geoms = self._get_polylines(self.RIVER_CENTERLINES)
         river_gdf = GeoDataFrame(
             river_dict,
             geometry=geoms,

rashdf/plan.py

@@ -5,6 +5,7 @@ from .utils import (
     df_datetimes_to_str,
     ras_timesteps_to_datetimes,
     parse_ras_datetime_ms,
+    deprecated,
 )
 
 from geopandas import GeoDataFrame
@@ -163,6 +164,8 @@ class RasPlanHdf(RasGeomHdf):
         f"{BASE_OUTPUT_PATH}/Summary Output/2D Flow Areas"
     )
     UNSTEADY_TIME_SERIES_PATH = f"{BASE_OUTPUT_PATH}/Unsteady Time Series"
+    REFERENCE_LINES_OUTPUT_PATH = f"{UNSTEADY_TIME_SERIES_PATH}/Reference Lines"
+    REFERENCE_POINTS_OUTPUT_PATH = f"{UNSTEADY_TIME_SERIES_PATH}/Reference Points"
 
     RESULTS_STEADY_PATH = "Results/Steady"
     BASE_STEADY_PATH = f"{RESULTS_STEADY_PATH}/Output/Output Blocks/Base Output"
@@ -583,7 +586,8 @@ class RasPlanHdf(RasGeomHdf):
         Returns
         -------
         DataFrame
-            A DataFrame with columns 'mesh_name', 'cell_id' or 'face_id', a value column, and a time column.
+            A DataFrame with columns 'mesh_name', 'cell_id' or 'face_id', a value column,
+            and a time column if the value corresponds to a specific time.
         """
         methods_with_times = {
             SummaryOutputVar.MAXIMUM_WATER_SURFACE: self.mesh_max_ws,
@@ -602,6 +606,76 @@ class RasPlanHdf(RasGeomHdf):
             df = other_methods[var]()
         return df
 
+    def _mesh_summary_outputs_df(
+        self,
+        cells_or_faces: str,
+        output_vars: Optional[List[SummaryOutputVar]] = None,
+        round_to: str = "0.1 s",
+    ) -> DataFrame:
+        if cells_or_faces == "cells":
+            feature_id_field = "cell_id"
+        elif cells_or_faces == "faces":
+            feature_id_field = "face_id"
+        else:
+            raise ValueError('cells_or_faces must be either "cells" or "faces".')
+        if output_vars is None:
+            summary_output_vars = self._summary_output_vars(
+                cells_or_faces=cells_or_faces
+            )
+        elif isinstance(output_vars, list):
+            summary_output_vars = []
+            for var in output_vars:
+                if not isinstance(var, SummaryOutputVar):
+                    var = SummaryOutputVar(var)
+                summary_output_vars.append(var)
+        else:
+            raise ValueError(
+                "include_output must be a boolean or a list of SummaryOutputVar values."
+            )
+        df = self.mesh_summary_output(summary_output_vars[0], round_to=round_to)
+        for var in summary_output_vars[1:]:
+            df_var = self.mesh_summary_output(var, round_to=round_to)
+            df = df.merge(df_var, on=["mesh_name", feature_id_field], how="left")
+        return df
+
+    def mesh_cells_summary_output(self, round_to: str = "0.1 s") -> DataFrame:
+        """
+        Return a DataFrame with summary output data for each mesh cell in the model.
+
+        Parameters
+        ----------
+        round_to : str, optional
+            The time unit to round the datetimes to. Default: "0.1 s" (seconds).
+            See Pandas documentation for valid time units:
+            https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html
+
+        Returns
+        -------
+        DataFrame
+            A DataFrame with columns 'mesh_name', 'cell_id', and columns for each
+            summary output variable.
+        """
+        return self._mesh_summary_outputs_df("cells", round_to=round_to)
+
+    def mesh_faces_summary_output(self, round_to: str = "0.1 s") -> DataFrame:
+        """
+        Return a DataFrame with summary output data for each mesh face in the model.
+
+        Parameters
+        ----------
+        round_to : str, optional
+            The time unit to round the datetimes to. Default: "0.1 s" (seconds).
+            See Pandas documentation for valid time units:
+            https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html
+
+        Returns
+        -------
+        DataFrame
+            A DataFrame with columns 'mesh_name', 'face_id', and columns for each
+            summary output variable.
+        """
+        return self._mesh_summary_outputs_df("faces", round_to=round_to)
+
     def _summary_output_vars(
         self, cells_or_faces: Optional[str] = None
     ) -> List[SummaryOutputVar]:
@@ -810,7 +884,7 @@ class RasPlanHdf(RasGeomHdf):
         mesh_name: str,
         var: TimeSeriesOutputVar,
     ) -> Tuple[np.ndarray, str]:
-        path = f"{self.UNSTEADY_TIME_SERIES_PATH}/2D Flow Areas/{mesh_name}/{var.value}"
+        path = self._mesh_timeseries_output_path(mesh_name, var.value)
         group = self.get(path)
         try:
             import dask.array as da
@@ -828,6 +902,7 @@ class RasPlanHdf(RasGeomHdf):
         self,
         mesh_name: str,
         var: Union[str, TimeSeriesOutputVar],
+        truncate: bool = True,
     ) -> xr.DataArray:
         """Return the time series output data for a given variable.
 
@@ -837,6 +912,8 @@ class RasPlanHdf(RasGeomHdf):
             The name of the 2D flow area mesh.
         var : TimeSeriesOutputVar
             The time series output variable to retrieve.
+        truncate : bool, optional
+            If True, truncate the number of cells to the listed cell count.
 
         Returns
         -------
@@ -854,7 +931,10 @@ class RasPlanHdf(RasGeomHdf):
         values, units = self._mesh_timeseries_output_values_units(mesh_name, var)
         if var in TIME_SERIES_OUTPUT_VARS_CELLS:
             cell_count = mesh_names_counts[mesh_name]
-            values = values[:, :cell_count]
+            if truncate:
+                values = values[:, :cell_count]
+            else:
+                values = values[:, :]
             id_coord = "cell_id"
         elif var in TIME_SERIES_OUTPUT_VARS_FACES:
             id_coord = "face_id"
@@ -872,24 +952,28 @@ class RasPlanHdf(RasGeomHdf):
                 "mesh_name": mesh_name,
                 "variable": var.value,
                 "units": units,
+                "hdf_path": self._mesh_timeseries_output_path(mesh_name, var.value),
             },
         )
         return da
 
+    def _mesh_timeseries_output_path(self, mesh_name: str, var_name: str) -> str:
+        return f"{self.UNSTEADY_TIME_SERIES_PATH}/2D Flow Areas/{mesh_name}/{var_name}"
+
     def _mesh_timeseries_outputs(
-        self, mesh_name: str, vars: List[TimeSeriesOutputVar]
+        self, mesh_name: str, vars: List[TimeSeriesOutputVar], truncate: bool = True
     ) -> xr.Dataset:
         datasets = {}
         for var in vars:
             var_path = f"{self.UNSTEADY_TIME_SERIES_PATH}/2D Flow Areas/{mesh_name}/{var.value}"
             if self.get(var_path) is None:
                 continue
-            da = self.mesh_timeseries_output(mesh_name, var)
+            da = self.mesh_timeseries_output(mesh_name, var, truncate=truncate)
             datasets[var.value] = da
         ds = xr.Dataset(datasets, attrs={"mesh_name": mesh_name})
         return ds
 
-    def mesh_timeseries_output_cells(self, mesh_name: str) -> xr.Dataset:
+    def mesh_cells_timeseries_output(self, mesh_name: str) -> xr.Dataset:
         """Return the time series output data for cells in a 2D flow area mesh.
 
         Parameters
@@ -905,7 +989,25 @@ class RasPlanHdf(RasGeomHdf):
         ds = self._mesh_timeseries_outputs(mesh_name, TIME_SERIES_OUTPUT_VARS_CELLS)
         return ds
 
-    def mesh_timeseries_output_faces(self, mesh_name: str) -> xr.Dataset:
+    @deprecated
+    def mesh_timeseries_output_cells(self, mesh_name: str) -> xr.Dataset:
+        """Return the time series output data for cells in a 2D flow area mesh.
+
+        Deprecated: use mesh_cells_timeseries_output instead.
+
+        Parameters
+        ----------
+        mesh_name : str
+            The name of the 2D flow area mesh.
+
+        Returns
+        -------
+        xr.Dataset
+            An xarray Dataset with DataArrays for each time series output variable.
+        """
+        return self.mesh_cells_timeseries_output(mesh_name)
+
+    def mesh_faces_timeseries_output(self, mesh_name: str) -> xr.Dataset:
         """Return the time series output data for faces in a 2D flow area mesh.
 
         Parameters
@@ -921,6 +1023,232 @@ class RasPlanHdf(RasGeomHdf):
         ds = self._mesh_timeseries_outputs(mesh_name, TIME_SERIES_OUTPUT_VARS_FACES)
         return ds
 
+    @deprecated
+    def mesh_timeseries_output_faces(self, mesh_name: str) -> xr.Dataset:
+        """Return the time series output data for faces in a 2D flow area mesh.
+
+        Deprecated: use mesh_faces_timeseries_output instead.
+
+        Parameters
+        ----------
+        mesh_name : str
+            The name of the 2D flow area mesh.
+
+        Returns
+        -------
+        xr.Dataset
+            An xarray Dataset with DataArrays for each time series output variable.
+        """
+        return self.mesh_faces_timeseries_output(mesh_name)
+
+    def reference_timeseries_output(self, reftype: str = "lines") -> xr.Dataset:
+        """Return timeseries output data for reference lines or points from a HEC-RAS HDF plan file.
+
+        Parameters
+        ----------
+        reftype : str, optional
+            The type of reference data to retrieve. Must be either "lines" or "points".
+            (default: "lines")
+
+        Returns
+        -------
+        xr.Dataset
+            An xarray Dataset with reference line timeseries data.
+        """
+        if reftype == "lines":
+            output_path = self.REFERENCE_LINES_OUTPUT_PATH
+            abbrev = "refln"
+        elif reftype == "points":
+            output_path = self.REFERENCE_POINTS_OUTPUT_PATH
+            abbrev = "refpt"
+        else:
+            raise ValueError('reftype must be either "lines" or "points".')
+        reference_group = self.get(output_path)
+        if reference_group is None:
+            raise RasPlanHdfError(
+                f"Could not find HDF group at path '{output_path}'."
+                f" Does the Plan HDF file contain reference {reftype[:-1]} output data?"
+            )
+        reference_names = reference_group["Name"][:]
+        names = []
+        mesh_areas = []
+        for s in reference_names:
+            name, mesh_area = s.decode("utf-8").split("|")
+            names.append(name)
+            mesh_areas.append(mesh_area)
+
+        times = self.unsteady_datetimes()
+
+        das = {}
+        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[:]
+            units = group.attrs["Units"].decode("utf-8")
+            da = xr.DataArray(
+                values,
+                name=var,
+                dims=["time", f"{abbrev}_id"],
+                coords={
+                    "time": times,
+                    f"{abbrev}_id": range(values.shape[1]),
+                    f"{abbrev}_name": (f"{abbrev}_id", names),
+                    "mesh_name": (f"{abbrev}_id", mesh_areas),
+                },
+                attrs={"units": units, "hdf_path": f"{output_path}/{var}"},
+            )
+            das[var] = da
+        return xr.Dataset(das)
+
+    def reference_lines_timeseries_output(self) -> xr.Dataset:
+        """Return timeseries output data for reference lines from a HEC-RAS HDF plan file.
+
+        Returns
+        -------
+        xr.Dataset
+            An xarray Dataset with timeseries output data for reference lines.
+        """
+        return self.reference_timeseries_output(reftype="lines")
+
+    def reference_points_timeseries_output(self) -> xr.Dataset:
+        """Return timeseries output data for reference points from a HEC-RAS HDF plan file.
+
+        Returns
+        -------
+        xr.Dataset
+            An xarray Dataset with timeseries output data for reference points.
+        """
+        return self.reference_timeseries_output(reftype="points")
+
+    def reference_summary_output(self, reftype: str = "lines") -> DataFrame:
+        """Return summary output data for reference lines or points from a HEC-RAS HDF plan file.
+
+        Returns
+        -------
+        DataFrame
+            A DataFrame with reference line summary output data.
+        """
+        if reftype == "lines":
+            abbrev = "refln"
+        elif reftype == "points":
+            abbrev = "refpt"
+        else:
+            raise ValueError('reftype must be either "lines" or "points".')
+        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 = {
+            "Flow": "q",
+            "Water Surface": "ws",
+            "Velocity": "v",
+        }
+        for var, abbrev in vars.items():
+            if var not in ds:
+                continue
+            max_var = ds[var].max(dim="time")
+            max_time = ds[var].time[ds[var].argmax(dim="time")]
+            min_var = ds[var].min(dim="time")
+            min_time = ds[var].time[ds[var].argmin(dim="time")]
+            result[f"max_{abbrev}"] = max_var
+            result[f"max_{abbrev}_time"] = max_time
+            result[f"min_{abbrev}"] = min_var
+            result[f"min_{abbrev}_time"] = min_time
+        return DataFrame(result)
+
+    def _reference_lines_points(
+        self,
+        reftype: str = "lines",
+        include_output: bool = True,
+        datetime_to_str: bool = False,
+    ) -> GeoDataFrame:
+        if reftype == "lines":
+            abbrev = "refln"
+            gdf = super().reference_lines()
+        elif reftype == "points":
+            abbrev = "refpt"
+            gdf = super().reference_points()
+        else:
+            raise ValueError('reftype must be either "lines" or "points".')
+        if include_output is False:
+            return gdf
+        summary_output = self.reference_summary_output(reftype=reftype)
+        gdf = gdf.merge(
+            summary_output,
+            on=[f"{abbrev}_id", f"{abbrev}_name", "mesh_name"],
+            how="left",
+        )
+        if datetime_to_str:
+            gdf = df_datetimes_to_str(gdf)
+        return gdf
+
+    def reference_lines(
+        self, include_output: bool = True, datetime_to_str: bool = False
+    ) -> GeoDataFrame:
+        """Return the reference lines from a HEC-RAS HDF plan file.
+
+        Includes summary output data for each reference line:
+        - Maximum flow & time (max_q, max_q_time)
+        - Minimum flow & time (min_q, min_q_time)
+        - Maximum water surface elevation & time (max_ws, max_ws_time)
+        - Minimum water surface elevation & time (min_ws, min_ws_time)
+
+        Parameters
+        ----------
+        include_output : bool, optional
+            If True, include summary output data in the GeoDataFrame. (default: True)
+        datetime_to_str : bool, optional
+            If True, convert datetime columns to strings. (default: False)
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame with reference line geometry and summary output data.
+        """
+        return self._reference_lines_points(
+            reftype="lines",
+            include_output=include_output,
+            datetime_to_str=datetime_to_str,
+        )
+
+    def reference_points(
+        self, include_output: bool = True, datetime_to_str: bool = False
+    ) -> GeoDataFrame:
+        """Return the reference points from a HEC-RAS HDF plan file.
+
+        Parameters
+        ----------
+        include_output : bool, optional
+            If True, include summary output data in the GeoDataFrame. (default: True)
+        datetime_to_str : bool, optional
+            If True, convert datetime columns to strings. (default: False)
+
+        Includes summary output data for each reference point:
+        - Maximum flow & time (max_q, max_q_time)
+        - Minimum flow & time (min_q, min_q_time)
+        - Maximum water surface elevation & time (max_ws, max_ws_time)
+        - Minimum water surface elevation & time (min_ws, min_ws_time)
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame with reference point geometry and summary output data.
+        """
+        return self._reference_lines_points(
+            reftype="points",
+            include_output=include_output,
+            datetime_to_str=datetime_to_str,
+        )
+
     def get_plan_info_attrs(self) -> Dict:
         """Return plan information attributes from a HEC-RAS HDF plan file.
 
@@ -1107,3 +1435,113 @@ class RasPlanHdf(RasGeomHdf):
             A DataFrame containing the velocity inside the cross sections
         """
         return self.steady_profile_xs_output(XsSteadyOutputVar.VELOCITY_TOTAL)
+
+    def _zmeta(self, ds: xr.Dataset) -> Dict:
+        """Given a xarray Dataset, return kerchunk-style zarr reference metadata."""
+        from kerchunk.hdf import SingleHdf5ToZarr
+        import zarr
+        import base64
+
+        encoding = {}
+        chunk_meta = {}
+
+        # Loop through each variable / DataArray in the Dataset
+        for var, da in ds.data_vars.items():
+            # The "hdf_path" attribute is the path within the HDF5 file
+            # that the DataArray was read from. This is attribute is inserted
+            # by rashdf (see "mesh_timeseries_output" method).
+            hdf_ds_path = da.attrs["hdf_path"]
+            hdf_ds = self.get(hdf_ds_path)
+            if hdf_ds is None:
+                # If we don't know where in the HDF5 the data came from, we
+                # have to skip it, because we won't be able to generate the
+                # correct metadata for it.
+                continue
+            # Get the filters and storage info for the HDF5 dataset.
+            # Calling private methods from Kerchunk here because
+            # there's not a nice public API for this part. This is hacky
+            # 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)
+            # Generate chunk metadata for the DataArray
+            for key, value in storage_info.items():
+                chunk_number = ".".join([str(k) for k in key])
+                chunk_key = f"{var}/{chunk_number}"
+                chunk_meta[chunk_key] = [str(self._loc), value["offset"], value["size"]]
+        # "Write" the Dataset to a temporary in-memory zarr store (which
+        # is the same a Python dictionary)
+        zarr_tmp = zarr.MemoryStore()
+        # Use compute=False here because we don't _actually_ want to write
+        # the data to the zarr store, we just want to generate the metadata.
+        ds.to_zarr(zarr_tmp, mode="w", compute=False, encoding=encoding)
+        zarr_meta = {"version": 1, "refs": {}}
+        # Loop through the in-memory Zarr store, decode the data to strings,
+        # and add it to the final metadata dictionary.
+        for key, value in zarr_tmp.items():
+            try:
+                value_str = value.decode("utf-8")
+            except UnicodeDecodeError:
+                value_str = "base64:" + base64.b64encode(value).decode("utf-8")
+            zarr_meta["refs"][key] = value_str
+        zarr_meta["refs"].update(chunk_meta)
+        return zarr_meta
+
+    def zmeta_mesh_cells_timeseries_output(self, mesh_name: str) -> Dict:
+        """Return kerchunk-style zarr reference metadata.
+
+        Requires the 'zarr' and 'kerchunk' packages.
+
+        Returns
+        -------
+        dict
+            Dictionary of kerchunk-style zarr reference metadata.
+        """
+        ds = self._mesh_timeseries_outputs(
+            mesh_name, TIME_SERIES_OUTPUT_VARS_CELLS, truncate=False
+        )
+        return self._zmeta(ds)
+
+    def zmeta_mesh_faces_timeseries_output(self, mesh_name: str) -> Dict:
+        """Return kerchunk-style zarr reference metadata.
+
+        Requires the 'zarr' and 'kerchunk' packages.
+
+        Returns
+        -------
+        dict
+            Dictionary of kerchunk-style zarr reference metadata.
+        """
+        ds = self._mesh_timeseries_outputs(
+            mesh_name, TIME_SERIES_OUTPUT_VARS_FACES, truncate=False
+        )
+        return self._zmeta(ds)
+
+    def zmeta_reference_lines_timeseries_output(self) -> Dict:
+        """Return kerchunk-style zarr reference metadata.
+
+        Requires the 'zarr' and 'kerchunk' packages.
+
+        Returns
+        -------
+        dict
+            Dictionary of kerchunk-style zarr reference metadata.
+        """
+        ds = self.reference_lines_timeseries_output()
+        return self._zmeta(ds)
+
+    def zmeta_reference_points_timeseries_output(self) -> Dict:
+        """Return kerchunk-style zarr reference metadata.
+
+        Requires the 'zarr' and 'kerchunk' packages.
+
+        Returns
+        -------
+        dict
+            Dictionary of kerchunk-style zarr reference metadata.
+        """
+        ds = self.reference_points_timeseries_output()
+        return self._zmeta(ds)

rashdf/utils.py

@@ -6,8 +6,8 @@ import pandas as pd
 
 from datetime import datetime, timedelta
 import re
-from typing import Any, List, Tuple, Union, Optional
-from shapely import LineString, Polygon, polygonize_full
+from typing import Any, Callable, List, Tuple, Union, Optional
+import warnings
 
 
 def parse_ras_datetime_ms(datetime_str: str) -> datetime:
@@ -308,3 +308,33 @@ 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.4.0.dist-info → rashdf-0.6.0.dist-info}/METADATA

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

rashdf-0.6.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+cli.py,sha256=yItWmCxnYLcuOpJVRpUsfv_NLS9IxLjojZB9GrxfKAU,6571
+rashdf/__init__.py,sha256=XXFtJDgLPCimqAhfsFz_pTWYECJiRT0i-Kb1uflXmVU,156
+rashdf/base.py,sha256=cAQJX1aeBJKb3MJ06ltpbRTUaZX5NkuxpR1J4f7FyTU,2507
+rashdf/geom.py,sha256=2aTfj6mqZGP6rysflQ5L8FeItlYJsknO00sKHo-yaTw,26090
+rashdf/plan.py,sha256=4kftqnZedhSWPl-5Yn3vz9Z4VifTXcUokti0s5lX1lU,56479
+rashdf/utils.py,sha256=Cba6sULF0m0jg6CQass4bPm2oxTd_avoe1pRQxq082c,10896
+rashdf-0.6.0.dist-info/LICENSE,sha256=L_0QaLpQVHPcglVjiaJPnOocwzP8uXevDRjUPr9DL1Y,1065
+rashdf-0.6.0.dist-info/METADATA,sha256=0MarTKZArGaOTTROyz4PENscSiVy7cYwvatftl89y_Q,5920
+rashdf-0.6.0.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+rashdf-0.6.0.dist-info/entry_points.txt,sha256=LHHMR1lLy4wRyscMuW1RlYDXemtPgqQhNcILz0DtStY,36
+rashdf-0.6.0.dist-info/top_level.txt,sha256=SrmLb6FFTJtM_t6O1v0M0JePshiQJMHr0yYVkHL7ztk,11
+rashdf-0.6.0.dist-info/RECORD,,

{rashdf-0.4.0.dist-info → rashdf-0.6.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.0)
+Generator: setuptools (71.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

rashdf-0.4.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-cli.py,sha256=dnTMEBid99xqorBFKZnUwOTDyTmIg08D83bSCkJ6104,5389
-rashdf/__init__.py,sha256=XXFtJDgLPCimqAhfsFz_pTWYECJiRT0i-Kb1uflXmVU,156
-rashdf/base.py,sha256=lHYVDwFTA1qFI34QYZ55QKcp7b8CeZsmDfESdkYISbg,2432
-rashdf/geom.py,sha256=z3ak4TYjYo8-jrIQNSU96S7ulX5xk67rFZ5J0Y9yKbI,22048
-rashdf/plan.py,sha256=YfJdjzZmGA9X8QnUflkc-8DMzMGoW5Gda3lRgMfxeQc,39669
-rashdf/utils.py,sha256=93arHtIT-iL9dIpbYr7esjrxv1uJabTRJSruyjvr8mw,10168
-rashdf-0.4.0.dist-info/LICENSE,sha256=L_0QaLpQVHPcglVjiaJPnOocwzP8uXevDRjUPr9DL1Y,1065
-rashdf-0.4.0.dist-info/METADATA,sha256=x7h2Pvw_xTQmzOhJKWkj6-R1lzCp_gDBt1wIkBikTZQ,5671
-rashdf-0.4.0.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-rashdf-0.4.0.dist-info/entry_points.txt,sha256=LHHMR1lLy4wRyscMuW1RlYDXemtPgqQhNcILz0DtStY,36
-rashdf-0.4.0.dist-info/top_level.txt,sha256=SrmLb6FFTJtM_t6O1v0M0JePshiQJMHr0yYVkHL7ztk,11
-rashdf-0.4.0.dist-info/RECORD,,