rashdf 0.8.3__tar.gz → 0.9.0__tar.gz

{rashdf-0.8.3 → rashdf-0.9.0}/PKG-INFO

@@ -1,16 +1,16 @@
 Metadata-Version: 2.4
 Name: rashdf
-Version: 0.8.3
+Version: 0.9.0
 Summary: Read data from HEC-RAS HDF files.
 Project-URL: repository, https://github.com/fema-ffrd/rashdf
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: h5py

{rashdf-0.8.3 → rashdf-0.9.0}/pyproject.toml

@@ -7,12 +7,12 @@ classifiers = [
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
-version = "0.8.3"
+version = "0.9.0"
 dependencies = ["h5py", "geopandas>=1.0,<2.0", "pyarrow", "xarray<=2025.4.0"]
 
 [project.optional-dependencies]

{rashdf-0.8.3 → rashdf-0.9.0}/src/cli.py

@@ -26,6 +26,7 @@ COMMANDS = [
     "reference_lines",
     "reference_points",
     "structures",
+    "generate_bridge_xs_lines",
 ]
 
 

{rashdf-0.8.3 → rashdf-0.9.0}/src/rashdf/geom.py

@@ -27,6 +27,8 @@ from .utils import (
     convert_ras_hdf_value,
     get_first_hdf_group,
     hdf5_attrs_to_dict,
+    copy_lines_parallel,
+    experimental,
 )
 
 
@@ -474,6 +476,67 @@ class RasGeomHdf(RasHdf):
     def connections(self) -> GeoDataFrame:  # noqa D102
         raise NotImplementedError
 
+    @experimental
+    def generate_bridge_xs_lines(self, datetime_to_str: bool = False) -> GeoDataFrame:
+        """[EXPERIMENTAL] Attempt to return the 2D bridge cross-section lines.
+
+        This method attempts to generate the cross-section lines for bridges modeled
+        within 2D mesh areas. It should be noted that these lines are not explicitly
+        stored within the HEC-RAS Geometry HDF file, and are instead generated based
+        on the bridge attributes and centerline geometry. As such, the accuracy of
+        these lines may vary depending on the complexity of the bridge geometry and
+        output from this method should be reviewed for accuracy.
+
+        Parameters
+        ----------
+        datetime_to_str : bool, optional
+            If True, convert datetime values to string format (default: False).
+
+        Returns
+        -------
+        GeoDataFrame
+            A GeoDataFrame containing the 2D bridge cross-section lines if they exist.
+        """
+        profile_info = self.get(self.GEOM_STRUCTURES_PATH + "/Table Info")
+        structs = self.structures().merge(
+            pd.DataFrame(profile_info[()] if profile_info is not None else None),
+            left_index=True,
+            right_index=True,
+        )
+        if structs.empty:
+            return GeoDataFrame()
+
+        bridges = structs[structs["Mode"] == "Bridge Opening"].copy()
+        if bridges.empty:
+            return GeoDataFrame()
+
+        inside_buffer_widths = bridges["Weir Width"] / 2
+        inside_bridge_xs = copy_lines_parallel(
+            bridges, inside_buffer_widths.values, "struct_id"
+        )
+        inside_bridge_xs["level"] = "inside"
+
+        outside_buffer_widths = inside_buffer_widths + bridges["Upstream Distance"]
+        outside_bridge_xs = copy_lines_parallel(
+            bridges, outside_buffer_widths.values, "struct_id"
+        )
+        outside_bridge_xs["level"] = "outside"
+
+        br_xs = GeoDataFrame(
+            pd.concat([inside_bridge_xs, outside_bridge_xs], ignore_index=True),
+            geometry="geometry",
+        )
+        br_xs.side = br_xs.side.apply(
+            lambda x: "upstream" if x == "right" else "downstream"
+        )
+
+        if datetime_to_str:
+            br_xs[self.LAST_EDITED_COLUMN] = br_xs[self.LAST_EDITED_COLUMN].apply(
+                lambda x: pd.Timestamp.isoformat(x)
+            )
+
+        return br_xs
+
     def ic_points(self) -> GeoDataFrame:  # noqa D102
         """Return initial conditions points.
 

{rashdf-0.8.3 → rashdf-0.9.0}/src/rashdf/plan.py

@@ -1178,7 +1178,7 @@ class RasPlanHdf(RasGeomHdf):
         xr.Dataset
             An xarray Dataset with timeseries output data for boundary conditions lines.
         """
-        df_bc_lines = self.bc_lines()
+        df_bc_lines = super().bc_lines()
         bc_lines_names = df_bc_lines["name"]
         datasets = []
         for bc_line_name in bc_lines_names:
@@ -1197,6 +1197,57 @@ class RasPlanHdf(RasGeomHdf):
         )
         return ds
 
+    def bc_lines(
+        self, include_output: bool = True, datetime_to_str: bool = False
+    ) -> GeoDataFrame:
+        """Return the boundary condition lines from a HEC-RAS HDF plan file.
+
+        Optionally include summary output data for each boundary condition line.
+
+        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 boundary condition line geometry and summary output data.
+        """
+        gdf = super().bc_lines()
+        if include_output is False:
+            return gdf
+
+        ds = self.bc_lines_timeseries_output()
+        summary = {
+            "bc_line_id": ds.coords["bc_line_id"].values,
+            "name": ds.coords["bc_line_name"].values,
+            "mesh_name": ds.coords["mesh_name"].values,
+            "type": ds.coords["bc_line_type"].values,
+        }
+
+        for var in ds.data_vars:
+            abbrev = "q" if var.lower() == "flow" else "ws"
+            summary[f"max_{abbrev}"] = ds[var].max(dim="time").values
+            summary[f"max_{abbrev}_time"] = (
+                ds[var].time[ds[var].argmax(dim="time")].values
+            )
+            summary[f"min_{abbrev}"] = ds[var].min(dim="time").values
+            summary[f"min_{abbrev}_time"] = (
+                ds[var].time[ds[var].argmin(dim="time")].values
+            )
+
+        gdf_with_output = gdf.merge(
+            pd.DataFrame(summary),
+            on=["bc_line_id", "name", "mesh_name", "type"],
+            how="left",
+        )
+        return (
+            df_datetimes_to_str(gdf_with_output) if datetime_to_str else gdf_with_output
+        )
+
     def observed_timeseries_input(self, vartype: str = "Flow") -> xr.DataArray:
         """Return observed timeseries input data for reference lines and points from a HEC-RAS HDF plan file.
 

{rashdf-0.8.3 → rashdf-0.9.0}/src/rashdf/utils.py

@@ -8,6 +8,68 @@ from datetime import datetime, timedelta
 import re
 from typing import Any, Callable, List, Tuple, Union, Optional
 import warnings
+from shapely import LineString, MultiLineString
+import geopandas as gpd
+
+
+def experimental(func) -> Callable:
+    """
+    Declare a function to be experimental.
+
+    This is a decorator which can be used to mark functions as experimental.
+    It will result in a warning being emitted when the function is used.
+
+    Parameters
+    ----------
+        func: The function to be declared experimental.
+
+    Returns
+    -------
+        The decorated function.
+    """
+
+    def new_func(*args, **kwargs):
+        warnings.warn(
+            f"{func.__name__} is experimental and could change in the future. Please review output carefully.",
+            category=UserWarning,
+            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 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:
@@ -36,24 +98,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.
     """
-    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, datetime_format)
-        parsed_dt += timedelta(days=1)
-    else:
-        parsed_dt = datetime.strptime(datetime_str, datetime_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.
@@ -139,32 +214,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
 
 
@@ -308,31 +388,129 @@ def ras_timesteps_to_datetimes(
     ]
 
 
-def deprecated(func) -> Callable:
+def remove_line_ends(
+    geom: Union[LineString, MultiLineString],
+) -> Union[LineString, MultiLineString]:
     """
-    Deprecate a function.
+    Remove endpoints from a LineString or each LineString in a MultiLineString if longer than 3 points.
 
-    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
+    ----------
+    geom : LineString or MultiLineString
+        The geometry to trim.
+
+    Returns
+    -------
+    LineString or MultiLineString
+        The trimmed geometry, or original if not enough points to trim.
+    """
+    if isinstance(geom, LineString):
+        coords = list(geom.coords)
+        if len(coords) > 3:
+            return LineString(coords[1:-1])
+        return geom
+    elif isinstance(geom, MultiLineString):
+        trimmed = []
+        for line in geom.geoms:
+            coords = list(line.coords)
+            if len(coords) > 3:
+                trimmed.append(LineString(coords[1:-1]))
+            else:
+                trimmed.append(line)
+        return MultiLineString(trimmed)
+    return geom
+
+
+def reverse_line(
+    line: Union[LineString, MultiLineString],
+) -> Union[LineString, MultiLineString]:
+    """
+    Reverse the order of coordinates in a LineString or each LineString in a MultiLineString.
 
     Parameters
     ----------
-        func: The function to be deprecated.
+    line : LineString or MultiLineString
+        The geometry to reverse.
 
     Returns
     -------
-        The decorated function.
+    LineString or MultiLineString
+        The reversed geometry.
     """
+    return (
+        MultiLineString([LineString(list(line.coords)[::-1]) for line in line.geoms])
+        if isinstance(line, MultiLineString)
+        else LineString(list(line.coords)[::-1])
+    )
+
+
+def copy_lines_parallel(
+    lines: gpd.GeoDataFrame,
+    offset_ft: Union[np.ndarray, float],
+    id_col: str = "id",
+) -> gpd.GeoDataFrame:
+    """
+    Create parallel copies of line geometries offset to the left and right, then trim and erase overlaps.
 
-    def new_func(*args, **kwargs):
-        warnings.warn(
-            f"{func.__name__} is deprecated and will be removed in a future version.",
-            category=DeprecationWarning,
-            stacklevel=2,
+    Parameters
+    ----------
+    lines : gpd.GeoDataFrame
+        GeoDataFrame containing line geometries.
+    offset_ft : float or np.ndarray
+        Offset distance (in feet) for parallel lines.
+    id_col : str
+        Name of the column containing unique structure IDs. Default is "id".
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        GeoDataFrame with trimmed, parallel left and right offset lines.
+    """
+    # Offset lines to the left
+    left = lines.copy()
+    offset_ft = offset_ft.astype(float)
+    left.geometry = lines.buffer(
+        offset_ft, cap_style="flat", single_sided=True, resolution=3
+    ).boundary
+    left["side"] = "left"
+
+    # Offset lines to the right (reverse direction first)
+    reversed_lines = lines.copy()
+    reversed_lines.geometry = reversed_lines.geometry.apply(reverse_line)
+    right = lines.copy()
+    right.geometry = reversed_lines.buffer(
+        offset_ft, cap_style="flat", single_sided=True, resolution=3
+    ).boundary.apply(reverse_line)
+    right["side"] = "right"
+
+    # Combine left and right boundaries
+    boundaries = pd.concat([left, right], ignore_index=True)
+    boundaries_gdf = gpd.GeoDataFrame(boundaries, crs=lines.crs, geometry="geometry")
+
+    # Erase buffer caps
+    erase_buffer = 0.1
+    cleaned_list = []
+    eraser = gpd.GeoDataFrame(
+        {
+            id_col: lines[id_col],
+            "geometry": lines.buffer(
+                offset_ft - erase_buffer, cap_style="square", resolution=3
+            ),
+        },
+        crs=lines.crs,
+    )
+    for id in lines[id_col].unique():
+        cleaned_list.append(
+            gpd.overlay(
+                boundaries_gdf[boundaries_gdf[id_col] == id],
+                eraser[eraser[id_col] == id],
+                how="difference",
+            )
         )
-        return func(*args, **kwargs)
+    cleaned = gpd.GeoDataFrame(
+        pd.concat(cleaned_list, ignore_index=True), crs=lines.crs, geometry="geometry"
+    )
 
-    new_func.__name__ = func.__name__
-    new_func.__doc__ = func.__doc__
-    new_func.__dict__.update(func.__dict__)
-    return new_func
+    # trim ends
+    cleaned["geometry"] = cleaned["geometry"].apply(remove_line_ends)
+    return cleaned

{rashdf-0.8.3 → rashdf-0.9.0}/src/rashdf.egg-info/PKG-INFO

@@ -1,16 +1,16 @@
 Metadata-Version: 2.4
 Name: rashdf
-Version: 0.8.3
+Version: 0.9.0
 Summary: Read data from HEC-RAS HDF files.
 Project-URL: repository, https://github.com/fema-ffrd/rashdf
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: h5py

{rashdf-0.8.3 → rashdf-0.9.0}/tests/test_geom.py

@@ -17,6 +17,7 @@ TEST_JSON = TEST_DATA / "json"
 BALD_EAGLE_P18_REF = TEST_DATA / "ras/BaldEagleDamBrk.reflines-refpts.p18.hdf"
 LOWER_KANAWHA_P01_IC_POINTS = TEST_DATA / "ras/LowerKanawha.p01.icpoints.hdf"
 LOWER_KANAWHA_P01_IC_POINTS_JSON = TEST_JSON / "LowerKanawha.p01.icpoints.geojson"
+ROSEBERRY_G01 = TEST_DATA / "ras/Roseberry_Creek.g01.hdf"
 
 TEST_ATTRS = {"test_attribute1": "test_str1", "test_attribute2": 500}
 
@@ -274,3 +275,16 @@ def test_ic_points():
             valid_gdf,
             check_dtype=False,
         )
+
+
+def test_generate_bridge_xs_lines():
+    bridge_xs_json = TEST_JSON / "bridge_xs_lines.json"
+    with RasGeomHdf(ROSEBERRY_G01) as ghdf:
+        assert _gdf_matches_json(
+            ghdf.generate_bridge_xs_lines(datetime_to_str=True), bridge_xs_json
+        )
+
+
+def test_generate_bridge_xs_lines_not_found():
+    with RasGeomHdf(MUNCIE_G05) as ghdf:
+        assert ghdf.generate_bridge_xs_lines().empty

{rashdf-0.8.3 → rashdf-0.9.0}/tests/test_plan.py

@@ -733,3 +733,18 @@ 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")
+
+
+def test_bc_lines_include_output_false():
+    bc_lines_json = TEST_JSON / "bc_lines.json"
+    with RasPlanHdf(MUNCIE_G05) as plan_hdf:
+        assert _gdf_matches_json(plan_hdf.bc_lines(include_output=False), bc_lines_json)
+
+
+def test_bc_lines_include_output_true():
+    bc_lines_with_output_json = TEST_JSON / "bc_lines_with_output.json"
+    with RasPlanHdf(LOWER_KANAWHA_P01_BC_LINES) as plan_hdf:
+        assert _gdf_matches_json(
+            plan_hdf.bc_lines(include_output=True, datetime_to_str=True),
+            bc_lines_with_output_json,
+        )

rashdf-0.9.0/tests/test_utils.py

@@ -0,0 +1,231 @@
+from src.rashdf import utils
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from datetime import datetime, timedelta
+from shapely.geometry import LineString, MultiLineString
+import geopandas as gpd
+from pathlib import Path
+
+from . import _assert_geodataframes_close
+
+TEST_DATA = Path("./tests/data")
+TEST_JSON = TEST_DATA / "json"
+
+
+def test_convert_ras_hdf_value():
+    assert utils.convert_ras_hdf_value(b"True") is True
+    assert utils.convert_ras_hdf_value(b"False") is False
+    assert utils.convert_ras_hdf_value(np.float32(1.23)) == pytest.approx(1.23)
+    assert utils.convert_ras_hdf_value(np.int32(123)) == 123
+    assert utils.convert_ras_hdf_value(b"15Mar2024 16:39:01") == datetime(
+        2024, 3, 15, 16, 39, 1
+    )
+    assert utils.convert_ras_hdf_value(b"15Mar2024 24:00:00") == datetime(
+        2024, 3, 16, 0, 0, 0
+    )
+    assert utils.convert_ras_hdf_value(b"15Mar2024 16:39:01 to 16Mar2024 16:39:01") == [
+        datetime(2024, 3, 15, 16, 39, 1),
+        datetime(2024, 3, 16, 16, 39, 1),
+    ]
+    assert utils.convert_ras_hdf_value(b"18Mar2024 24:00:00 to 19Mar2024 24:00:00") == [
+        datetime(2024, 3, 19, 0, 0, 0),
+        datetime(2024, 3, 20, 0, 0, 0),
+    ]
+    assert utils.convert_ras_hdf_value(b"01:23:45") == timedelta(
+        hours=1, minutes=23, seconds=45
+    )
+    assert utils.convert_ras_hdf_value(b"15Mar2024 2400") == datetime(
+        2024, 3, 16, 0, 0, 0
+    )
+    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),
+    ]
+    assert utils.convert_ras_hdf_value(b"18Mar2024 2400 to 19Mar2024 2400") == [
+        datetime(2024, 3, 19, 0, 0, 0),
+        datetime(2024, 3, 20, 0, 0, 0),
+    ]
+
+
+def test_df_datetimes_to_str():
+    df = pd.DataFrame(
+        {
+            "datetime": [
+                datetime(2024, 3, 15, 16, 39, 1),
+                datetime(2024, 3, 16, 16, 39, 1),
+            ],
+            "asdf": [
+                0.123,
+                0.456,
+            ],
+        }
+    )
+    assert df["datetime"].dtype.name == "datetime64[ns]"
+    df = utils.df_datetimes_to_str(df)
+    assert df["datetime"].dtype.name == "object"
+    assert df["datetime"].tolist() == ["2024-03-15T16:39:01", "2024-03-16T16:39:01"]
+    assert df["asdf"].tolist() == [0.123, 0.456]
+
+
+def test_parse_ras_datetime_ms():
+    assert utils.parse_ras_datetime_ms("15Mar2024 16:39:01.123") == datetime(
+        2024, 3, 15, 16, 39, 1, 123000
+    )
+    assert utils.parse_ras_datetime_ms("15Mar2024 24:00:00.000") == datetime(
+        2024, 3, 16, 0, 0, 0, 0
+    )
+
+
+def test_trim_line():
+    gdf = gpd.GeoDataFrame(
+        {
+            "id": [1, 2, 3],
+            "geometry": [
+                LineString([(0, 0), (5, 5), (10, 10)]),
+                LineString([(0, 0), (5, 5), (10, 10), (15, 15)]),
+                MultiLineString(
+                    [
+                        [(0, 0), (3, 3)],
+                        [(3, 3), (6, 6), (9, 9)],
+                        [(3, 3), (6, 6), (9, 9), (12, 12), (15, 15)],
+                    ]
+                ),
+            ],
+        },
+    )
+    assert gdf.geometry.apply(utils.remove_line_ends).equals(
+        gpd.GeoSeries(
+            [
+                LineString([(0, 0), (5, 5), (10, 10)]),
+                LineString(
+                    [
+                        (5, 5),
+                        (10, 10),
+                    ]
+                ),
+                MultiLineString(
+                    [
+                        [(0, 0), (3, 3)],
+                        [(3, 3), (6, 6), (9, 9)],
+                        [(6, 6), (9, 9), (12, 12)],
+                    ]
+                ),
+            ]
+        )
+    )
+
+
+def test_reverse_line():
+    gdf = gpd.GeoDataFrame(
+        {
+            "id": [1, 2, 3],
+            "geometry": [
+                LineString([(0, 0), (5, 5), (10, 10)]),
+                LineString([(0, 0), (5, 5), (10, 10), (15, 15)]),
+                MultiLineString(
+                    [
+                        [(0, 0), (3, 3)],
+                        [(3, 3), (6, 6), (9, 9)],
+                        [(3, 3), (6, 6), (9, 9), (12, 12), (15, 15)],
+                    ]
+                ),
+            ],
+        },
+    )
+    assert gdf.geometry.apply(utils.reverse_line).equals(
+        gpd.GeoSeries(
+            [
+                LineString([(10, 10), (5, 5), (0, 0)]),
+                LineString([(15, 15), (10, 10), (5, 5), (0, 0)]),
+                MultiLineString(
+                    [
+                        [(3, 3), (0, 0)],
+                        [(9, 9), (6, 6), (3, 3)],
+                        [(15, 15), (12, 12), (9, 9), (6, 6), (3, 3)],
+                    ]
+                ),
+            ]
+        )
+    )
+
+
+def test_copy_lines_parallel():
+    gdf = gpd.GeoDataFrame(
+        {
+            "id": [1, 2, 3],
+            "geometry": [
+                LineString([(0, 0), (5, 5), (10, 10)]),
+                LineString([(20, 20), (30, 30), (40, 40), (50, 50)]),
+                MultiLineString(
+                    [
+                        [(100.0, 100.0), (103.0, 103.0)],
+                        [(103.0, 103.0), (106.0, 106.0), (109.0, 109.0)],
+                        [
+                            (103.0, 103.0),
+                            (106.0, 106.0),
+                            (109.0, 109.0),
+                            (112.0, 112.0),
+                            (115.0, 115.0),
+                        ],
+                    ]
+                ),
+            ],
+        },
+    )
+    offsets = np.array([1, 2, 3])
+    copied = utils.copy_lines_parallel(gdf, offsets)
+    expected = gpd.read_file(TEST_JSON / "copy_lines_parallel.json").set_crs(
+        None, allow_override=True
+    )
+    _assert_geodataframes_close(copied, expected, tol=1e-3)

rashdf-0.8.3/tests/test_utils.py

@@ -1,75 +0,0 @@
-from src.rashdf import utils
-
-import numpy as np
-import pandas as pd
-import pytest
-
-from datetime import datetime, timedelta
-
-
-def test_convert_ras_hdf_value():
-    assert utils.convert_ras_hdf_value(b"True") is True
-    assert utils.convert_ras_hdf_value(b"False") is False
-    assert utils.convert_ras_hdf_value(np.float32(1.23)) == pytest.approx(1.23)
-    assert utils.convert_ras_hdf_value(np.int32(123)) == 123
-    assert utils.convert_ras_hdf_value(b"15Mar2024 16:39:01") == datetime(
-        2024, 3, 15, 16, 39, 1
-    )
-    assert utils.convert_ras_hdf_value(b"15Mar2024 24:00:00") == datetime(
-        2024, 3, 16, 0, 0, 0
-    )
-    assert utils.convert_ras_hdf_value(b"15Mar2024 16:39:01 to 16Mar2024 16:39:01") == [
-        datetime(2024, 3, 15, 16, 39, 1),
-        datetime(2024, 3, 16, 16, 39, 1),
-    ]
-    assert utils.convert_ras_hdf_value(b"18Mar2024 24:00:00 to 19Mar2024 24:00:00") == [
-        datetime(2024, 3, 19, 0, 0, 0),
-        datetime(2024, 3, 20, 0, 0, 0),
-    ]
-    assert utils.convert_ras_hdf_value(b"01:23:45") == timedelta(
-        hours=1, minutes=23, seconds=45
-    )
-    assert utils.convert_ras_hdf_value(b"15Mar2024 2400") == datetime(
-        2024, 3, 16, 0, 0, 0
-    )
-    assert utils.convert_ras_hdf_value(b"15Mar2024 2315") == datetime(
-        2024, 3, 15, 23, 15, 0
-    )
-
-    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),
-    ]
-    assert utils.convert_ras_hdf_value(b"18Mar2024 2400 to 19Mar2024 2400") == [
-        datetime(2024, 3, 19, 0, 0, 0),
-        datetime(2024, 3, 20, 0, 0, 0),
-    ]
-
-
-def test_df_datetimes_to_str():
-    df = pd.DataFrame(
-        {
-            "datetime": [
-                datetime(2024, 3, 15, 16, 39, 1),
-                datetime(2024, 3, 16, 16, 39, 1),
-            ],
-            "asdf": [
-                0.123,
-                0.456,
-            ],
-        }
-    )
-    assert df["datetime"].dtype.name == "datetime64[ns]"
-    df = utils.df_datetimes_to_str(df)
-    assert df["datetime"].dtype.name == "object"
-    assert df["datetime"].tolist() == ["2024-03-15T16:39:01", "2024-03-16T16:39:01"]
-    assert df["asdf"].tolist() == [0.123, 0.456]
-
-
-def test_parse_ras_datetime_ms():
-    assert utils.parse_ras_datetime_ms("15Mar2024 16:39:01.123") == datetime(
-        2024, 3, 15, 16, 39, 1, 123000
-    )
-    assert utils.parse_ras_datetime_ms("15Mar2024 24:00:00.000") == datetime(
-        2024, 3, 16, 0, 0, 0, 0
-    )