ras-commander 0.61.0__py3-none-any.whl → 0.64.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
 
         
 """
@@ -234,8 +238,17 @@ class RasPlan:
         if not plan_file_path:
             raise FileNotFoundError(f"Plan file not found: {plan_number}")
         
+        def update_unsteady_in_file(lines):
+            updated_lines = []
+            for line in lines:
+                if line.startswith("Flow File="):
+                    updated_lines.append(f"Flow File=u{new_unsteady_flow_number}\n")
+                else:
+                    updated_lines.append(line)
+            return updated_lines
+        
         try:
-            RasUtils.update_file(plan_file_path, RasPlan._update_unsteady_in_file, new_unsteady_flow_number)
+            RasUtils.update_file(plan_file_path, update_unsteady_in_file)
         except Exception as e:
             raise Exception(f"Failed to update unsteady flow file: {e}")
 
@@ -245,10 +258,6 @@ class RasPlan:
         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):
@@ -1257,3 +1266,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()

ras_commander/RasPrj.py

@@ -161,47 +161,92 @@ class RasPrj:
 
         This method initializes DataFrames for plan, flow, unsteady, and geometry entries
         by calling the _get_prj_entries method for each entry type.
+        Also extracts unsteady_number and geometry_number from plan files and adds them to plan_df.
         """
-        # Initialize DataFrames
+        # Load unsteady first to ensure consistent handling of unsteady numbers
+        self.unsteady_df = self._get_prj_entries('Unsteady')
         self.plan_df = self._get_prj_entries('Plan')
         self.flow_df = self._get_prj_entries('Flow')
-        self.unsteady_df = self._get_prj_entries('Unsteady')
-        self.geom_df = self.get_geom_entries()  # Use get_geom_entries instead of _get_prj_entries
+        self.geom_df = self.get_geom_entries()
+        
+        # Initialize Geom_File column
+        self.plan_df['Geom_File'] = None
+        
+        # Set geometry HDF paths
+        for idx, row in self.plan_df.iterrows():
+            try:
+                plan_file_path = row['full_path']
+                geom_number, geom_hdf_path = self._get_geom_file_from_plan(plan_file_path)
+                if geom_number:
+                    self.plan_df.at[idx, 'Geom_File'] = geom_hdf_path
+                    if not self.suppress_logging:
+                        logger.info(f"Plan {row['plan_number']} uses geometry file {geom_number}")
+            except Exception as e:
+                logger.error(f"Error processing plan file {row['plan_number']}: {e}")
+
+    def _get_geom_file_from_plan(self, plan_file_path):
+        """
+        Extract the geometry number from a plan file by finding the Geom File value
+        and stripping the leading 'g'.
+        
+        Parameters:
+        -----------
+        plan_file_path : str or Path
+            Path to the plan file.
+        
+        Returns:
+        --------
+        tuple: (str, str)
+            A tuple containing (geometry_number, full_hdf_path) or (None, None) if not found.
+            geometry_number is the number after 'g' in the Geom File value
+            full_hdf_path is the path to the geometry HDF file
+        """
+        content, encoding = read_file_with_fallback_encoding(plan_file_path)
+        
+        if content is None:
+            return None, None
         
-        # Add Geom_File to plan_df
-        self.plan_df['Geom_File'] = self.plan_df.apply(lambda row: self._get_geom_file_for_plan(row['plan_number']), axis=1)
+        try:
+            match = re.search(r'Geom File=g(\d+)', content)
+            if match:
+                geom_number = match.group(1)  # This gets just the number after 'g'
+                geom_file = f"g{geom_number}"
+                geom_hdf_path = self.project_folder / f"{self.project_name}.{geom_file}.hdf"
+                if geom_hdf_path.exists():
+                    return geom_number, str(geom_hdf_path)
+        except Exception as e:
+            logger.error(f"Error extracting geometry number from {plan_file_path}: {e}")
+        
+        return None, None
 
-    
-    def _get_geom_file_for_plan(self, plan_number):
+    def _get_flow_file_from_plan(self, plan_file_path):
         """
-        Get the geometry file path for a given plan number.
+        Extract the Flow File value from a plan file.
         
-        Args:
-            plan_number (str): The plan number to find the geometry file for.
+        Parameters:
+        -----------
+        plan_file_path : str or Path
+            Path to the plan file.
         
         Returns:
-            str: The full path to the geometry HDF file, or None if not found.
+        --------
+        str or None
+            The Flow File value or None if not found.
         """
-        plan_file_path = self.project_folder / f"{self.project_name}.p{plan_number}"
         content, encoding = read_file_with_fallback_encoding(plan_file_path)
         
         if content is None:
             return None
         
         try:
-            for line in content.splitlines():
-                if line.startswith("Geom File="):
-                    geom_file = line.strip().split('=')[1]
-                    geom_hdf_path = self.project_folder / f"{self.project_name}.{geom_file}.hdf"
-                    if geom_hdf_path.exists():
-                        return str(geom_hdf_path)
-                    else:
-                        return None
+            match = re.search(r'Flow File=([^\s]+)', content)
+            if match:
+                return match.group(1)
         except Exception as e:
-            logger.error(f"Error reading plan file for geometry: {e}")
+            logger.error(f"Error extracting Flow File from {plan_file_path}: {e}")
+        
         return None
 
-
     @staticmethod
     @log_call
     def get_plan_value(
@@ -376,19 +421,16 @@ class RasPrj:
         
         return plan_info
 
+    @log_call
     def _get_prj_entries(self, entry_type):
         """
         Extract entries of a specific type from the HEC-RAS project file.
-
+        
         Args:
             entry_type (str): The type of entry to extract (e.g., 'Plan', 'Flow', 'Unsteady', 'Geom').
-
+        
         Returns:
             pd.DataFrame: A DataFrame containing the extracted entries.
-
-        Note:
-            This method reads the project file and extracts entries matching the specified type.
-            For 'Unsteady' entries, it parses additional information from the unsteady file.
         """
         entries = []
         pattern = re.compile(rf"{entry_type} File=(\w+)")
@@ -400,28 +442,69 @@ class RasPrj:
                     if match:
                         file_name = match.group(1)
                         full_path = str(self.project_folder / f"{self.project_name}.{file_name}")
+                        entry_number = file_name[1:]  # Extract number portion without prefix
+                        
                         entry = {
-                            f'{entry_type.lower()}_number': file_name[1:],
+                            f'{entry_type.lower()}_number': entry_number,
                             'full_path': full_path
                         }
-
-                        if entry_type == 'Plan':
-                            plan_info = self._parse_plan_file(Path(full_path))
-                            entry.update(plan_info)
-                            
-                            hdf_results_path = self.project_folder / f"{self.project_name}.p{file_name[1:]}.hdf"
-                            entry['HDF_Results_Path'] = str(hdf_results_path) if hdf_results_path.exists() else None
-
+                        
                         if entry_type == 'Unsteady':
+                            entry['unsteady_number'] = entry_number
                             unsteady_info = self._parse_unsteady_file(Path(full_path))
                             entry.update(unsteady_info)
+                        else:
+                            entry.update({
+                                'unsteady_number': None,
+                                'geometry_number': None,
+                                'Short Identifier': None,
+                                'Simulation Date': None
+                            })
+                        
+                        if entry_type == 'Plan':
+                            plan_info = self._parse_plan_file(Path(full_path))
+                            if plan_info:
+                                # Handle Flow File (unsteady) number
+                                flow_file = plan_info.get('Flow File')
+                                if flow_file and flow_file.startswith('u'):
+                                    entry['unsteady_number'] = flow_file[1:]
+                                else:
+                                    entry['unsteady_number'] = flow_file
+                                    
+                                # Handle Geom File number
+                                geom_file = plan_info.get('Geom File')
+                                if geom_file and geom_file.startswith('g'):
+                                    entry['geometry_number'] = geom_file[1:]
+                                else:
+                                    entry['geometry_number'] = geom_file
+                                    
+                                entry['Short Identifier'] = plan_info.get('Short Identifier')
+                                entry['Simulation Date'] = plan_info.get('Simulation Date')
+                                
+                                # Update remaining fields
+                                for key, value in plan_info.items():
+                                    if key not in ['unsteady_number', 'geometry_number', 'Short Identifier', 
+                                                 'Simulation Date', 'Flow File', 'Geom File']:
+                                        entry[key] = value
+                        
+                            # Add HDF results path
+                            hdf_results_path = self.project_folder / f"{self.project_name}.p{entry_number}.hdf"
+                            entry['HDF_Results_Path'] = str(hdf_results_path) if hdf_results_path.exists() else None
 
                         entries.append(entry)
+        
+            df = pd.DataFrame(entries)
+            
+            if not df.empty and entry_type == 'Plan':
+                first_cols = [f'{entry_type.lower()}_number', 'unsteady_number', 'geometry_number', 
+                            'Short Identifier', 'Simulation Date']
+                other_cols = [col for col in df.columns if col not in first_cols]
+                df = df[first_cols + other_cols]
+            
+            return df
         except Exception as e:
             raise
 
-        return pd.DataFrame(entries)
-
     def _parse_unsteady_file(self, unsteady_file_path):
         """
         Parse an unsteady flow file and extract critical information.
@@ -811,6 +894,28 @@ class RasPrj:
         
         return bc_info, unparsed_lines
 
+    @log_call
+    def get_unsteady_numbers_from_plans(self):
+        """
+        Get all plans that use unsteady flow files.
+        
+        Returns:
+        --------
+        pd.DataFrame
+            A DataFrame containing only plan entries that use unsteady flow files.
+        
+        Raises:
+        -------
+        RuntimeError: If the project has not been initialized.
+        """
+        self.check_initialized()
+        
+        # Filter plan_df to only include plans with unsteady_number not None
+        unsteady_plans = self.plan_df[self.plan_df['unsteady_number'].notna()].copy()
+        
+        logger.info(f"Found {len(unsteady_plans)} plans using unsteady flow files")
+        
+        return unsteady_plans
 
 # Create a global instance named 'ras'
 # Defining the global instance allows the init_ras_project function to initialize the project.
@@ -881,8 +986,8 @@ def get_ras_exe(ras_version=None):
     
     Args:
         ras_version (str, optional): Either a version number or a full path to the HEC-RAS executable.
-                                     If None, the function will attempt to use the version from the global 'ras' object
-                                     or a default path.
+                                     If None, the function will first check the global 'ras' object for a path.
+                                     If the global 'ras' object is not initialized or doesn't have a path, a default path will be used.
     
     Returns:
         str: The full path to the HEC-RAS executable.