ras-commander 0.61.0__py3-none-any.whl → 0.65.0__py3-none-any.whl

ras_commander/HdfBndry.py

@@ -122,6 +122,12 @@ class HdfBndry:
         -------
         gpd.GeoDataFrame
             A GeoDataFrame containing the breaklines.
+
+        Notes
+        -----
+        - Zero-length breaklines are logged and skipped. 
+        - Single-point breaklines are logged and skipped.
+        - These invalid breaklines should be removed in RASMapper to prevent potential issues.
         """
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
@@ -129,17 +135,95 @@ class HdfBndry:
                 if breaklines_path not in hdf_file:
                     logger.warning(f"Breaklines path '{breaklines_path}' not found in HDF file.")
                     return gpd.GeoDataFrame()
+
                 bl_line_data = hdf_file[breaklines_path]
-                bl_line_ids = range(bl_line_data["Attributes"][()].shape[0])
-                names = np.vectorize(HdfUtils.convert_ras_string)(
-                    bl_line_data["Attributes"][()]["Name"]
-                )
-                geoms = HdfBase.get_polylines_from_parts(hdf_path, breaklines_path)
+                attributes = bl_line_data["Attributes"][()]
+                
+                # Initialize lists to store valid breakline data
+                valid_ids = []
+                valid_names = []
+                valid_geoms = []
+
+                # Track invalid breaklines for summary
+                zero_length_count = 0
+                single_point_count = 0
+                other_error_count = 0
+
+                # Process each breakline
+                for idx, (pnt_start, pnt_cnt, part_start, part_cnt) in enumerate(bl_line_data["Polyline Info"][()]):
+                    name = HdfUtils.convert_ras_string(attributes["Name"][idx])
+
+                    # Check for zero-length breaklines
+                    if pnt_cnt == 0:
+                        zero_length_count += 1
+                        logger.debug(f"Zero-length breakline found (FID: {idx}, Name: {name})")
+                        continue
+
+                    # Check for single-point breaklines
+                    if pnt_cnt == 1:
+                        single_point_count += 1
+                        logger.debug(f"Single-point breakline found (FID: {idx}, Name: {name})")
+                        continue
+
+                    try:
+                        points = bl_line_data["Polyline Points"][()][pnt_start:pnt_start + pnt_cnt]
+                        
+                        # Additional validation of points array
+                        if len(points) < 2:
+                            single_point_count += 1
+                            logger.debug(f"Invalid point count in breakline (FID: {idx}, Name: {name})")
+                            continue
+
+                        if part_cnt == 1:
+                            geom = LineString(points)
+                        else:
+                            parts = bl_line_data["Polyline Parts"][()][part_start:part_start + part_cnt]
+                            geom = MultiLineString([
+                                points[part_pnt_start:part_pnt_start + part_pnt_cnt]
+                                for part_pnt_start, part_pnt_cnt in parts
+                                if part_pnt_cnt > 1  # Skip single-point parts
+                            ])
+                            # Skip if no valid parts remain
+                            if len(geom.geoms) == 0:
+                                other_error_count += 1
+                                logger.debug(f"No valid parts in multipart breakline (FID: {idx}, Name: {name})")
+                                continue
+
+                        valid_ids.append(idx)
+                        valid_names.append(name)
+                        valid_geoms.append(geom)
+
+                    except Exception as e:
+                        other_error_count += 1
+                        logger.debug(f"Error processing breakline {idx}: {str(e)}")
+                        continue
+
+                # Log summary of invalid breaklines
+                total_invalid = zero_length_count + single_point_count + other_error_count
+                if total_invalid > 0:
+                    logger.info(
+                        f"Breakline processing summary:\n"
+                        f"- Zero-length breaklines: {zero_length_count}\n"
+                        f"- Single-point breaklines: {single_point_count}\n"
+                        f"- Other invalid breaklines: {other_error_count}\n"
+                        f"Consider removing these invalid breaklines using RASMapper."
+                    )
+
+                # Create GeoDataFrame with valid breaklines
+                if not valid_ids:
+                    logger.warning("No valid breaklines found in the HDF file.")
+                    return gpd.GeoDataFrame()
+
                 return gpd.GeoDataFrame(
-                    {"bl_id": bl_line_ids, "Name": names, "geometry": geoms},
+                    {
+                        "bl_id": valid_ids,
+                        "Name": valid_names,
+                        "geometry": valid_geoms
+                    },
                     geometry="geometry",
-                    crs=HdfBase.get_projection(hdf_file),
+                    crs=HdfBase.get_projection(hdf_file)
                 )
+
         except Exception as e:
             logger.error(f"Error reading breaklines: {str(e)}")
             return gpd.GeoDataFrame()

ras_commander/HdfInfiltration.py

@@ -47,7 +47,7 @@ from pathlib import Path
 import pandas as pd
 import geopandas as gpd
 import h5py
-from rasterstats import zonal_stats
+
 from .Decorators import log_call, standardize_input
 
 class HdfInfiltration:
@@ -232,6 +232,12 @@ class HdfInfiltration:
         Returns:
             DataFrame with soil statistics including percentages and areas
         """
+        
+        try:
+            from rasterstats import zonal_stats
+        except ImportError as e:
+            logger.error("Failed to import rasterstats. Please run 'pip install rasterstats' and try again.")
+            raise e
         # Initialize areas dictionary
         mukey_areas = {mukey: 0 for mukey in raster_map.values()}
         

ras_commander/HdfPlan.py

@@ -50,6 +50,8 @@ import pandas as pd
 from datetime import datetime
 from pathlib import Path
 from typing import Dict, List, Optional
+import re
+import numpy as np
 
 from .HdfBase import HdfBase
 from .HdfUtils import HdfUtils
@@ -178,7 +180,7 @@ class HdfPlan:
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def get_plan_parameters(hdf_path: Path) -> Dict:
+    def get_plan_parameters(hdf_path: Path) -> pd.DataFrame:
         """
         Get plan parameter attributes from a HEC-RAS HDF plan file.
 
@@ -186,7 +188,10 @@ class HdfPlan:
             hdf_path (Path): Path to the HEC-RAS plan HDF file.
 
         Returns:
-            Dict: A dictionary containing the plan parameter attributes.
+            pd.DataFrame: A DataFrame containing the plan parameters with columns:
+                - Parameter: Name of the parameter
+                - Value: Value of the parameter (decoded if byte string)
+                - Plan: Plan number (01-99) extracted from the filename (ProjectName.pXX.hdf)
 
         Raises:
             ValueError: If there's an error retrieving the plan parameter attributes.
@@ -197,14 +202,48 @@ class HdfPlan:
                 if plan_params_path not in hdf_file:
                     raise ValueError(f"Plan Parameters not found in {hdf_path}")
                 
-                attrs = {}
+                # Extract parameters
+                params_dict = {}
                 for key in hdf_file[plan_params_path].attrs.keys():
                     value = hdf_file[plan_params_path].attrs[key]
+                    
+                    # Handle different types of values
                     if isinstance(value, bytes):
                         value = HdfUtils.convert_ras_string(value)
-                    attrs[key] = value
+                    elif isinstance(value, np.ndarray):
+                        # Handle array values
+                        if value.dtype.kind in {'S', 'a'}:  # Array of byte strings
+                            value = [v.decode('utf-8') if isinstance(v, bytes) else v for v in value]
+                        else:
+                            value = value.tolist()  # Convert numpy array to list
+                        
+                        # If it's a single-item list, extract the value
+                        if len(value) == 1:
+                            value = value[0]
+                    
+                    params_dict[key] = value
                 
-                return attrs
+                # Create DataFrame from parameters
+                df = pd.DataFrame.from_dict(params_dict, orient='index', columns=['Value'])
+                df.index.name = 'Parameter'
+                df = df.reset_index()
+                
+                # Extract plan number from filename
+                filename = Path(hdf_path).name
+                plan_match = re.search(r'\.p(\d{2})\.', filename)
+                if plan_match:
+                    plan_num = plan_match.group(1)
+                else:
+                    plan_num = "00"  # Default if no match found
+                    logger.warning(f"Could not extract plan number from filename: {filename}")
+                
+                df['Plan'] = plan_num
+                
+                # Reorder columns to put Plan first
+                df = df[['Plan', 'Parameter', 'Value']]
+                
+                return df
+
         except Exception as e:
             raise ValueError(f"Failed to get plan parameter attributes: {str(e)}")
 

ras_commander/HdfResultsMesh.py

@@ -609,12 +609,8 @@ class HdfResultsMesh:
         Returns
         -------
         gpd.GeoDataFrame
-            A GeoDataFrame containing the summary output data with attributes as metadata.
-
-        Raises
-        ------
-        ValueError
-            If the HDF file cannot be opened or read, or if the requested data is not found.
+            A GeoDataFrame containing the summary output data with decoded attributes as metadata.
+            Returns empty GeoDataFrame if variable is not found.
         """
         try:
             dfs = []
@@ -623,13 +619,19 @@ class HdfResultsMesh:
             logger.info(f"Processing summary output for variable: {var}")
             d2_flow_areas = hdf_file.get("Geometry/2D Flow Areas/Attributes")
             if d2_flow_areas is None:
+                logger.info("No 2D Flow Areas found in HDF file")
                 return gpd.GeoDataFrame()
 
             for d2_flow_area in d2_flow_areas[:]:
                 mesh_name = HdfUtils.convert_ras_string(d2_flow_area[0])
                 cell_count = d2_flow_area[-1]
                 logger.debug(f"Processing mesh: {mesh_name} with {cell_count} cells")
-                group = HdfResultsMesh.get_mesh_summary_output_group(hdf_file, mesh_name, var)
+                
+                try:
+                    group = HdfResultsMesh.get_mesh_summary_output_group(hdf_file, mesh_name, var)
+                except ValueError:
+                    logger.info(f"Variable '{var}' not present in output file for mesh '{mesh_name}', skipping")
+                    continue
                 
                 data = group[:]
                 logger.debug(f"Data shape for {var} in {mesh_name}: {data.shape}")
@@ -639,7 +641,7 @@ class HdfResultsMesh:
                 if data.ndim == 2 and data.shape[0] == 2:
                     # Handle 2D datasets (e.g. Maximum Water Surface)
                     row_variables = group.attrs.get('Row Variables', [b'Value', b'Time'])
-                    row_variables = [v.decode('utf-8').strip() for v in row_variables]
+                    row_variables = [v.decode('utf-8').strip() if isinstance(v, bytes) else v for v in row_variables]
                     
                     df = pd.DataFrame({
                         "mesh_name": [mesh_name] * data.shape[1],
@@ -676,14 +678,22 @@ class HdfResultsMesh:
                                     on=['mesh_name', 'cell_id'], 
                                     how='left')
                 
-                # Add group attributes as metadata
+                # Add group attributes as metadata with proper decoding
                 df.attrs['mesh_name'] = mesh_name
                 for attr_name, attr_value in group.attrs.items():
                     if isinstance(attr_value, bytes):
-                        attr_value = attr_value.decode('utf-8')
+                        # Decode single byte string
+                        decoded_value = attr_value.decode('utf-8')
                     elif isinstance(attr_value, np.ndarray):
-                        attr_value = attr_value.tolist()
-                    df.attrs[attr_name] = attr_value
+                        if attr_value.dtype.kind in {'S', 'a'}:  # Array of byte strings
+                            # Decode array of byte strings
+                            decoded_value = [v.decode('utf-8') if isinstance(v, bytes) else v for v in attr_value]
+                        else:
+                            # Convert other numpy arrays to list
+                            decoded_value = attr_value.tolist()
+                    else:
+                        decoded_value = attr_value
+                    df.attrs[attr_name] = decoded_value
                 
                 dfs.append(df)
             
@@ -700,7 +710,7 @@ class HdfResultsMesh:
             if crs:
                 gdf.set_crs(crs, inplace=True)
             
-            # Combine attributes from all meshes
+            # Combine attributes from all meshes with decoded values
             combined_attrs = {}
             for df in dfs:
                 for key, value in df.attrs.items():
@@ -737,6 +747,6 @@ class HdfResultsMesh:
         output_path = f"Results/Unsteady/Output/Output Blocks/Base Output/Summary Output/2D Flow Areas/{mesh_name}/{var}"
         output_item = hdf_file.get(output_path)
         if output_item is None:
-            raise ValueError(f"Could not find HDF group or dataset at path '{output_path}'")
+            raise ValueError(f"Dataset not found at path '{output_path}'")
         return output_item