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

ras_commander/HdfStruc.py

@@ -81,9 +81,20 @@ class HdfStruc:
         try:
             with h5py.File(hdf_path, 'r') as hdf:
                 if "Geometry/Structures" not in hdf:
-                    logger.info(f"No structures found in: {hdf_path}")
+                    logger.error(f"No Structures Found in the HDF, Empty Geodataframe Returned: {hdf_path}")
                     return GeoDataFrame()
                 
+                # Check if required datasets exist
+                required_datasets = [
+                    "Geometry/Structures/Centerline Info",
+                    "Geometry/Structures/Centerline Points"
+                ]
+                
+                for dataset in required_datasets:
+                    if dataset not in hdf:
+                        logger.error(f"No Structures Found in the HDF, Empty Geodataframe Returned: {hdf_path}")
+                        return GeoDataFrame()
+
                 def get_dataset_df(path: str) -> pd.DataFrame:
                     """
                     Converts an HDF5 dataset to a pandas DataFrame.
@@ -244,7 +255,7 @@ class HdfStruc:
     @staticmethod
     @log_call
     @standardize_input(file_type='geom_hdf')
-    def get_geom_structures_attrs(hdf_path: Path) -> Dict[str, Any]:
+    def get_geom_structures_attrs(hdf_path: Path) -> pd.DataFrame:
         """
         Extracts structure attributes from a HEC-RAS geometry HDF file.
 
@@ -255,9 +266,9 @@ class HdfStruc:
 
         Returns
         -------
-        Dict[str, Any]
-            Dictionary of structure attributes from the Geometry/Structures group.
-            Returns empty dict if no structures are found.
+        pd.DataFrame
+            DataFrame containing structure attributes from the Geometry/Structures group.
+            Returns empty DataFrame if no structures are found.
 
         Notes
         -----
@@ -268,8 +279,19 @@ class HdfStruc:
             with h5py.File(hdf_path, 'r') as hdf_file:
                 if "Geometry/Structures" not in hdf_file:
                     logger.info(f"No structures found in the geometry file: {hdf_path}")
-                    return {}
-                return HdfUtils.convert_hdf5_attrs_to_dict(hdf_file["Geometry/Structures"].attrs)
+                    return pd.DataFrame()
+                
+                # Get attributes and decode byte strings
+                attrs_dict = {}
+                for key, value in dict(hdf_file["Geometry/Structures"].attrs).items():
+                    if isinstance(value, bytes):
+                        attrs_dict[key] = value.decode('utf-8')
+                    else:
+                        attrs_dict[key] = value
+                
+                # Create DataFrame with a single row index
+                return pd.DataFrame(attrs_dict, index=[0])
+                
         except Exception as e:
             logger.error(f"Error reading geometry structures attributes: {str(e)}")
-            return {}
+            return pd.DataFrame()

ras_commander/RasMapper.py

@@ -21,85 +21,4 @@ from .HdfInfiltration import HdfInfiltration
 
 class RasMapper:
     """Class for handling RAS Mapper operations and data extraction"""
-
-    @staticmethod
-    @log_call
-    def get_raster_map(hdf_path: Path) -> dict:
-        """Read the raster map from HDF file and create value mapping
-        
-        Args:
-            hdf_path: Path to the HDF file
-            
-        Returns:
-            Dictionary mapping raster values to mukeys
-        """
-        with h5py.File(hdf_path, 'r') as hdf:
-            raster_map_data = hdf['Raster Map'][:]
-            return {int(item[0]): item[1].decode('utf-8') for item in raster_map_data}
-
-    @staticmethod
-    @log_call 
-    def clip_raster_with_boundary(raster_path: Path, boundary_path: Path):
-        """Clip a raster using a boundary polygon
-        
-        Args:
-            raster_path: Path to the raster file
-            boundary_path: Path to the boundary shapefile
-            
-        Returns:
-            Tuple of (clipped_image, transform, nodata_value)
-        """
-        watershed = gpd.read_file(boundary_path)
-        raster = rasterio.open(raster_path)
-        
-        out_image, out_transform = mask(raster, watershed.geometry, crop=True)
-        nodata = raster.nodatavals[0]
-        
-        return out_image[0], out_transform, nodata
-
-    @staticmethod
-    @log_call
-    def calculate_zonal_stats(boundary_path: Path, raster_data, transform, nodata):
-        """Calculate zonal statistics for a boundary
-        
-        Args:
-            boundary_path: Path to boundary shapefile
-            raster_data: Numpy array of raster values
-            transform: Raster transform
-            nodata: Nodata value
-            
-        Returns:
-            List of statistics by zone
-        """
-        watershed = gpd.read_file(boundary_path)
-        return zonal_stats(watershed, raster_data, 
-                         affine=transform, 
-                         nodata=nodata,
-                         categorical=True)
-
-# Example usage:
-"""
-# Initialize paths
-raster_path = Path('input_files/gSSURGO_InfiltrationDC.tif')
-boundary_path = Path('input_files/WF_Boundary_Simple.shp')
-hdf_path = raster_path.with_suffix('.hdf')
-
-# Get raster mapping
-raster_map = RasMapper.get_raster_map(hdf_path)
-
-# Clip raster with boundary
-clipped_data, transform, nodata = RasMapper.clip_raster_with_boundary(
-    raster_path, boundary_path)
-
-# Calculate zonal statistics
-stats = RasMapper.calculate_zonal_stats(
-    boundary_path, clipped_data, transform, nodata)
-
-# Calculate soil statistics
-soil_stats = HdfInfiltration.calculate_soil_statistics(
-    stats, raster_map)
-
-# Get significant mukeys (>1%)
-significant_mukeys = HdfInfiltration.get_significant_mukeys(
-    soil_stats, threshold=1.0)
-"""
+    # PLACEHOLDER FOR FUTURE DEVELOPMENT

ras_commander/RasPlan.py

@@ -50,6 +50,10 @@ List of Functions in RasPlan:
 - update_plan_description(): Update the description in a plan file
 - read_plan_description(): Read the description from a plan file
 - update_simulation_date(): Update simulation start and end dates
+- get_shortid(): Get the Short Identifier from a plan file
+- set_shortid(): Set the Short Identifier in a plan file
+- get_plan_title(): Get the Plan Title from a plan file 
+- set_plan_title(): Set the Plan Title in a plan file
 
         
 """
@@ -101,11 +105,10 @@ class RasPlan:
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
 
-        # Ensure plan_number and new_geom are strings
         plan_number = str(plan_number).zfill(2)
         new_geom = str(new_geom).zfill(2)
 
-        # Before doing anything, make sure the plan, geom, flow, and unsteady dataframes are current
+        # Update all dataframes
         ras_obj.plan_df = ras_obj.get_plan_entries()
         ras_obj.geom_df = ras_obj.get_geom_entries()
         ras_obj.flow_df = ras_obj.get_flow_entries()
@@ -115,18 +118,15 @@ class RasPlan:
             logger.error(f"Geometry {new_geom} not found in project.")
             raise ValueError(f"Geometry {new_geom} not found in project.")
 
-        # Update the geometry for the specified plan
-        ras_obj.plan_df.loc[ras_obj.plan_df['plan_number'] == plan_number, 'geom_number'] = new_geom
+        # Update all geometry-related columns
+        mask = ras_obj.plan_df['plan_number'] == plan_number
+        ras_obj.plan_df.loc[mask, 'geometry_number'] = new_geom
+        ras_obj.plan_df.loc[mask, 'Geom File'] = new_geom
+        geom_path = ras_obj.project_folder / f"{ras_obj.project_name}.g{new_geom}"
+        ras_obj.plan_df.loc[mask, 'Geom Path'] = str(geom_path)
 
-        logger.info(f"Geometry for plan {plan_number} set to {new_geom}")
-        logger.debug("Updated plan DataFrame:")
-        logger.debug(ras_obj.plan_df)
-
-        # Update the project file
-        prj_file_path = ras_obj.prj_file
-        RasUtils.update_file(prj_file_path, RasPlan._update_geom_in_file, plan_number, new_geom)
-
-        # Re-initialize the ras object to reflect changes
+        # Update project file and reinitialize
+        RasUtils.update_file(ras_obj.prj_file, RasPlan._update_geom_in_file, plan_number, new_geom)
         ras_obj.initialize(ras_obj.project_folder, ras_obj.ras_exe_path)
 
         return ras_obj.plan_df
@@ -173,21 +173,26 @@ class RasPlan:
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
                         
-        # Update the flow dataframe in the ras instance to ensure it is current
         ras_obj.flow_df = ras_obj.get_flow_entries()
         
         if new_steady_flow_number not in ras_obj.flow_df['flow_number'].values:
             raise ValueError(f"Steady flow number {new_steady_flow_number} not found in project file.")
         
-        # Resolve the full path of the plan file
         plan_file_path = RasPlan.get_plan_path(plan_number, ras_obj)
         if not plan_file_path:
             raise FileNotFoundError(f"Plan file not found: {plan_number}")
         
         RasUtils.update_file(plan_file_path, RasPlan._update_steady_in_file, new_steady_flow_number)
 
-        # Update the ras object's dataframes
+        # Update dataframes and additional columns
         ras_obj.plan_df = ras_obj.get_plan_entries()
+        mask = ras_obj.plan_df['plan_number'] == plan_number
+        flow_path = ras_obj.project_folder / f"{ras_obj.project_name}.f{new_steady_flow_number}"
+        ras_obj.plan_df.loc[mask, 'Flow File'] = new_steady_flow_number
+        ras_obj.plan_df.loc[mask, 'Flow Path'] = str(flow_path)
+        ras_obj.plan_df.loc[mask, 'unsteady_number'] = None
+
+        # Update remaining dataframes
         ras_obj.geom_df = ras_obj.get_geom_entries()
         ras_obj.flow_df = ras_obj.get_flow_entries()
         ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
@@ -223,32 +228,37 @@ class RasPlan:
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
         
-        # Update the unsteady dataframe in the ras instance to ensure it is current
         ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
         
         if new_unsteady_flow_number not in ras_obj.unsteady_df['unsteady_number'].values:
             raise ValueError(f"Unsteady number {new_unsteady_flow_number} not found in project file.")
         
-        # Get the full path of the plan file
         plan_file_path = RasPlan.get_plan_path(plan_number, ras_obj)
         if not plan_file_path:
             raise FileNotFoundError(f"Plan file not found: {plan_number}")
         
         try:
-            RasUtils.update_file(plan_file_path, RasPlan._update_unsteady_in_file, new_unsteady_flow_number)
+            RasUtils.update_file(plan_file_path, lambda lines: [
+                f"Flow File=u{new_unsteady_flow_number}\n" if line.startswith("Flow File=") else line 
+                for line in lines
+            ])
+            
+            # Update dataframes and additional columns
+            ras_obj.plan_df = ras_obj.get_plan_entries()
+            mask = ras_obj.plan_df['plan_number'] == plan_number
+            flow_path = ras_obj.project_folder / f"{ras_obj.project_name}.u{new_unsteady_flow_number}"
+            ras_obj.plan_df.loc[mask, 'Flow File'] = new_unsteady_flow_number
+            ras_obj.plan_df.loc[mask, 'Flow Path'] = str(flow_path)
+            ras_obj.plan_df.loc[mask, 'unsteady_number'] = new_unsteady_flow_number
+            
+            # Update remaining dataframes
+            ras_obj.geom_df = ras_obj.get_geom_entries()
+            ras_obj.flow_df = ras_obj.get_flow_entries()
+            ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
+            
         except Exception as e:
             raise Exception(f"Failed to update unsteady flow file: {e}")
 
-        # Update the ras object's dataframes
-        ras_obj.plan_df = ras_obj.get_plan_entries()
-        ras_obj.geom_df = ras_obj.get_geom_entries()
-        ras_obj.flow_df = ras_obj.get_flow_entries()
-        ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
-
-    @staticmethod
-    def _update_unsteady_in_file(lines, new_unsteady_flow_number):
-        return [f"Unsteady File=u{new_unsteady_flow_number}\n" if line.startswith("Unsteady File=u") else line for line in lines]
-    
     @staticmethod
     @log_call
     def set_num_cores(plan_number, num_cores, ras_object=None):
@@ -601,36 +611,31 @@ class RasPlan:
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
 
-        # Update plan entries without reinitializing the entire project
         ras_obj.plan_df = ras_obj.get_prj_entries('Plan')
-
         new_plan_num = RasPlan.get_next_number(ras_obj.plan_df['plan_number'])
+        
         template_plan_path = ras_obj.project_folder / f"{ras_obj.project_name}.p{template_plan}"
         new_plan_path = ras_obj.project_folder / f"{ras_obj.project_name}.p{new_plan_num}"
 
-        def update_shortid(lines):
-            shortid_pattern = re.compile(r'^Short Identifier=(.*)$', re.IGNORECASE)
-            for i, line in enumerate(lines):
-                match = shortid_pattern.match(line.strip())
-                if match:
-                    current_shortid = match.group(1)
-                    if new_plan_shortid is None:
-                        new_shortid = (current_shortid + "_copy")[:24]
-                    else:
-                        new_shortid = new_plan_shortid[:24]
-                    lines[i] = f"Short Identifier={new_shortid}\n"
-                    break
-            return lines
-
-        # Use RasUtils to clone the file and update the short identifier
-        RasUtils.clone_file(template_plan_path, new_plan_path, update_shortid)
-
-        # Use RasUtils to update the project file
+        # Clone file and update project file
+        RasUtils.clone_file(template_plan_path, new_plan_path, 
+                           lambda lines: [
+                               f"Short Identifier={new_plan_shortid or (match.group(1) + '_copy')[:24]}\n"
+                               if (match := re.match(r'^Short Identifier=(.*)$', line.strip(), re.IGNORECASE))
+                               else line
+                               for line in lines
+                           ])
+        
         RasUtils.update_project_file(ras_obj.prj_file, 'Plan', new_plan_num, ras_object=ras_obj)
-
-        # Re-initialize the ras global object
         ras_obj.initialize(ras_obj.project_folder, ras_obj.ras_exe_path)
+        
+        # Copy additional columns from template to new plan
+        template_row = ras_obj.plan_df[ras_obj.plan_df['plan_number'] == template_plan].iloc[0]
+        for col in ['Geom File', 'Geom Path', 'Flow File', 'Flow Path']:
+            if col in template_row.index:
+                ras_obj.plan_df.loc[ras_obj.plan_df['plan_number'] == new_plan_num, col] = template_row[col]
 
+        # Update all dataframes
         ras_obj.plan_df = ras_obj.get_plan_entries()
         ras_obj.geom_df = ras_obj.get_geom_entries()
         ras_obj.flow_df = ras_obj.get_flow_entries()
@@ -881,7 +886,8 @@ class RasPlan:
             'Run HTab', 'Run Post Process', 'Run Sediment', 'Run UNET', 'Run WQNET',
             'Short Identifier', 'Simulation Date', 'UNET D1 Cores', 'UNET D2 Cores', 'PS Cores',
             'UNET Use Existing IB Tables', 'UNET 1D Methodology', 'UNET D2 Solver Type', 
-            'UNET D2 Name', 'Run RASMapper', 'Run HTab', 'Run UNET'
+            'UNET D2 Name', 'Run RASMapper', 'Run HTab', 'Run UNet', 'Run PostProcess',
+            'Run WQNet', 'UNET P2 Cores', 'Run Post Process', 'Run WQNET'
         }
 
         if key not in supported_plan_keys:
@@ -1257,3 +1263,207 @@ class RasPlan:
             ras_object.plan_df = ras_object.get_plan_entries()
             ras_object.unsteady_df = ras_object.get_unsteady_entries()
 
+    @staticmethod
+    @log_call
+    def get_shortid(plan_number_or_path: Union[str, Path], ras_object=None) -> str:
+        """
+        Get the Short Identifier from a HEC-RAS plan file.
+
+        Args:
+            plan_number_or_path (Union[str, Path]): The plan number or path to the plan file.
+            ras_object (Optional[RasPrj]): The RAS project object. If None, uses the global 'ras' object.
+
+        Returns:
+            str: The Short Identifier from the plan file.
+
+        Raises:
+            ValueError: If the plan file is not found.
+            IOError: If there's an error reading from the plan file.
+
+        Example:
+            >>> shortid = RasPlan.get_shortid('01')
+            >>> print(f"Plan's Short Identifier: {shortid}")
+        """
+        logger = get_logger(__name__)
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+
+        # Get the Short Identifier using get_plan_value
+        shortid = RasPlan.get_plan_value(plan_number_or_path, "Short Identifier", ras_obj)
+        
+        if shortid is None:
+            logger.warning(f"Short Identifier not found in plan: {plan_number_or_path}")
+            return ""
+        
+        logger.info(f"Retrieved Short Identifier: {shortid}")
+        return shortid
+
+    @staticmethod
+    @log_call
+    def set_shortid(plan_number_or_path: Union[str, Path], new_shortid: str, ras_object=None) -> None:
+        """
+        Set the Short Identifier in a HEC-RAS plan file.
+
+        Args:
+            plan_number_or_path (Union[str, Path]): The plan number or path to the plan file.
+            new_shortid (str): The new Short Identifier to set (max 24 characters).
+            ras_object (Optional[RasPrj]): The RAS project object. If None, uses the global 'ras' object.
+
+        Raises:
+            ValueError: If the plan file is not found or if new_shortid is too long.
+            IOError: If there's an error updating the plan file.
+
+        Example:
+            >>> RasPlan.set_shortid('01', 'NewShortIdentifier')
+        """
+        logger = get_logger(__name__)
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+
+        # Ensure new_shortid is not too long (HEC-RAS limits short identifiers to 24 characters)
+        if len(new_shortid) > 24:
+            logger.warning(f"Short Identifier too long (24 char max). Truncating: {new_shortid}")
+            new_shortid = new_shortid[:24]
+
+        # Get the plan file path
+        plan_file_path = Path(plan_number_or_path)
+        if not plan_file_path.is_file():
+            plan_file_path = RasUtils.get_plan_path(plan_number_or_path, ras_obj)
+            if not plan_file_path.exists():
+                logger.error(f"Plan file not found: {plan_file_path}")
+                raise ValueError(f"Plan file not found: {plan_file_path}")
+
+        try:
+            # Read the file
+            with open(plan_file_path, 'r') as file:
+                lines = file.readlines()
+
+            # Update the Short Identifier line
+            updated = False
+            for i, line in enumerate(lines):
+                if line.startswith("Short Identifier="):
+                    lines[i] = f"Short Identifier={new_shortid}\n"
+                    updated = True
+                    break
+
+            # If Short Identifier line not found, add it after Plan Title
+            if not updated:
+                for i, line in enumerate(lines):
+                    if line.startswith("Plan Title="):
+                        lines.insert(i+1, f"Short Identifier={new_shortid}\n")
+                        updated = True
+                        break
+                
+                # If Plan Title not found either, add at the beginning
+                if not updated:
+                    lines.insert(0, f"Short Identifier={new_shortid}\n")
+
+            # Write the updated content back to the file
+            with open(plan_file_path, 'w') as file:
+                file.writelines(lines)
+
+            logger.info(f"Updated Short Identifier in plan file to: {new_shortid}")
+
+        except IOError as e:
+            logger.error(f"Error updating Short Identifier in plan file {plan_file_path}: {e}")
+            raise ValueError(f"Error updating Short Identifier: {e}")
+
+        # Refresh RasPrj dataframes if ras_object provided
+        if ras_object:
+            ras_object.plan_df = ras_object.get_plan_entries()
+
+    @staticmethod
+    @log_call
+    def get_plan_title(plan_number_or_path: Union[str, Path], ras_object=None) -> str:
+        """
+        Get the Plan Title from a HEC-RAS plan file.
+
+        Args:
+            plan_number_or_path (Union[str, Path]): The plan number or path to the plan file.
+            ras_object (Optional[RasPrj]): The RAS project object. If None, uses the global 'ras' object.
+
+        Returns:
+            str: The Plan Title from the plan file.
+
+        Raises:
+            ValueError: If the plan file is not found.
+            IOError: If there's an error reading from the plan file.
+
+        Example:
+            >>> title = RasPlan.get_plan_title('01')
+            >>> print(f"Plan Title: {title}")
+        """
+        logger = get_logger(__name__)
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+
+        # Get the Plan Title using get_plan_value
+        title = RasPlan.get_plan_value(plan_number_or_path, "Plan Title", ras_obj)
+        
+        if title is None:
+            logger.warning(f"Plan Title not found in plan: {plan_number_or_path}")
+            return ""
+        
+        logger.info(f"Retrieved Plan Title: {title}")
+        return title
+
+    @staticmethod
+    @log_call
+    def set_plan_title(plan_number_or_path: Union[str, Path], new_title: str, ras_object=None) -> None:
+        """
+        Set the Plan Title in a HEC-RAS plan file.
+
+        Args:
+            plan_number_or_path (Union[str, Path]): The plan number or path to the plan file.
+            new_title (str): The new Plan Title to set.
+            ras_object (Optional[RasPrj]): The RAS project object. If None, uses the global 'ras' object.
+
+        Raises:
+            ValueError: If the plan file is not found.
+            IOError: If there's an error updating the plan file.
+
+        Example:
+            >>> RasPlan.set_plan_title('01', 'Updated Plan Scenario')
+        """
+        logger = get_logger(__name__)
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+
+        # Get the plan file path
+        plan_file_path = Path(plan_number_or_path)
+        if not plan_file_path.is_file():
+            plan_file_path = RasUtils.get_plan_path(plan_number_or_path, ras_obj)
+            if not plan_file_path.exists():
+                logger.error(f"Plan file not found: {plan_file_path}")
+                raise ValueError(f"Plan file not found: {plan_file_path}")
+
+        try:
+            # Read the file
+            with open(plan_file_path, 'r') as file:
+                lines = file.readlines()
+
+            # Update the Plan Title line
+            updated = False
+            for i, line in enumerate(lines):
+                if line.startswith("Plan Title="):
+                    lines[i] = f"Plan Title={new_title}\n"
+                    updated = True
+                    break
+
+            # If Plan Title line not found, add it at the beginning
+            if not updated:
+                lines.insert(0, f"Plan Title={new_title}\n")
+
+            # Write the updated content back to the file
+            with open(plan_file_path, 'w') as file:
+                file.writelines(lines)
+
+            logger.info(f"Updated Plan Title in plan file to: {new_title}")
+
+        except IOError as e:
+            logger.error(f"Error updating Plan Title in plan file {plan_file_path}: {e}")
+            raise ValueError(f"Error updating Plan Title: {e}")
+
+        # Refresh RasPrj dataframes if ras_object provided
+        if ras_object:
+            ras_object.plan_df = ras_object.get_plan_entries()