ras-commander 0.77.0__py3-none-any.whl → 0.78.0__py3-none-any.whl

ras_commander/RasExamples.py

@@ -69,6 +69,12 @@ class RasExamples:
     examples_dir = base_dir
     projects_dir = examples_dir / 'example_projects'
     csv_file_path = examples_dir / 'example_projects.csv'
+    
+    # Special projects that are not in the main zip file
+    SPECIAL_PROJECTS = {
+        'NewOrleansMetro': 'https://www.hec.usace.army.mil/confluence/rasdocs/hgt/files/latest/299502039/299502111/1/1747692522764/NewOrleansMetroPipesExample.zip',
+        'BeaverLake': 'https://www.hec.usace.army.mil/confluence/rasdocs/hgt/files/latest/299501780/299502090/1/1747692179014/BeaverLake-SWMM-Import-Solution.zip'
+    }
 
     _folder_df = None
     _zip_file_path = None
@@ -148,6 +154,17 @@ class RasExamples:
         extracted_paths = []
 
         for project_name in project_names:
+            # Check if this is a special project
+            if project_name in cls.SPECIAL_PROJECTS:
+                try:
+                    special_path = cls._extract_special_project(project_name)
+                    extracted_paths.append(special_path)
+                    continue
+                except Exception as e:
+                    logger.error(f"Failed to extract special project '{project_name}': {e}")
+                    continue
+            
+            # Regular project extraction logic
             logger.info("----- RasExamples Extracting Project -----")
             logger.info(f"Extracting project '{project_name}'")
             project_path = cls.projects_dir
@@ -319,6 +336,9 @@ class RasExamples:
     def list_projects(cls, category=None):
         """
         List all projects or projects in a specific category.
+        
+        Note: Special projects (NewOrleansMetro, BeaverLake) are also available but not listed
+        in categories as they are downloaded separately.
         """
         if cls._folder_df is None:
             logger.warning("No projects available. Make sure the zip file is properly loaded.")
@@ -328,7 +348,10 @@ class RasExamples:
             logger.info(f"Projects in category '{category}': {', '.join(projects)}")
         else:
             projects = cls._folder_df['Project'].unique()
-            logger.info(f"All available projects: {', '.join(projects)}")
+            # Add special projects to the list
+            all_projects = list(projects) + list(cls.SPECIAL_PROJECTS.keys())
+            logger.info(f"All available projects: {', '.join(all_projects)}")
+            return all_projects
         return projects.tolist()
 
     @classmethod
@@ -421,4 +444,100 @@ class RasExamples:
             raise ValueError(f"Invalid size string: {size_str}")
         
         number, unit = float(re.findall(r'[\d\.]+', size_str)[0]), re.findall(r'[BKMGT]B?', size_str)[0]
-        return int(number * units[unit])
+        return int(number * units[unit])
+
+    @classmethod
+    def _extract_special_project(cls, project_name: str) -> Path:
+        """
+        Download and extract special projects that are not in the main zip file.
+        
+        Args:
+            project_name: Name of the special project ('NewOrleansMetro' or 'BeaverLake')
+            
+        Returns:
+            Path: Path to the extracted project directory
+            
+        Raises:
+            ValueError: If the project is not a recognized special project
+        """
+        if project_name not in cls.SPECIAL_PROJECTS:
+            raise ValueError(f"'{project_name}' is not a recognized special project")
+        
+        logger.info(f"----- RasExamples Extracting Special Project -----")
+        logger.info(f"Extracting special project '{project_name}'")
+        
+        # Create the project directory
+        project_path = cls.projects_dir / project_name
+        
+        # Check if already exists
+        if project_path.exists():
+            logger.info(f"Special project '{project_name}' already exists. Deleting existing folder...")
+            try:
+                shutil.rmtree(project_path)
+                logger.info(f"Existing folder for project '{project_name}' has been deleted.")
+            except Exception as e:
+                logger.error(f"Failed to delete existing project folder '{project_name}': {e}")
+                raise
+        
+        # Create the project directory
+        project_path.mkdir(parents=True, exist_ok=True)
+        
+        # Download the zip file
+        url = cls.SPECIAL_PROJECTS[project_name]
+        zip_file_path = cls.projects_dir / f"{project_name}_temp.zip"
+        
+        logger.info(f"Downloading special project from: {url}")
+        logger.info("This may take a few moments...")
+        
+        try:
+            response = requests.get(url, stream=True, timeout=300)
+            response.raise_for_status()
+            
+            # Get total file size if available
+            total_size = int(response.headers.get('content-length', 0))
+            
+            # Download with progress bar
+            with open(zip_file_path, 'wb') as file:
+                if total_size > 0:
+                    with tqdm(
+                        desc=f"Downloading {project_name}",
+                        total=total_size,
+                        unit='iB',
+                        unit_scale=True,
+                        unit_divisor=1024,
+                    ) as progress_bar:
+                        for chunk in response.iter_content(chunk_size=8192):
+                            size = file.write(chunk)
+                            progress_bar.update(size)
+                else:
+                    # No content length, download without progress bar
+                    for chunk in response.iter_content(chunk_size=8192):
+                        file.write(chunk)
+            
+            logger.info(f"Downloaded special project zip file to {zip_file_path}")
+            
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Failed to download special project '{project_name}': {e}")
+            if zip_file_path.exists():
+                zip_file_path.unlink()
+            raise
+        
+        # Extract the zip file directly to the project directory
+        try:
+            with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:
+                # Extract directly to the project directory (no internal folder structure)
+                zip_ref.extractall(project_path)
+            logger.info(f"Successfully extracted special project '{project_name}' to {project_path}")
+            
+        except Exception as e:
+            logger.error(f"Failed to extract special project '{project_name}': {e}")
+            if project_path.exists():
+                shutil.rmtree(project_path)
+            raise
+        finally:
+            # Clean up the temporary zip file
+            if zip_file_path.exists():
+                zip_file_path.unlink()
+                logger.debug(f"Removed temporary zip file: {zip_file_path}")
+        
+        return project_path

ras_commander/RasGeo.py

@@ -206,10 +206,10 @@ class RasGeo:
         
         # Create DataFrame
         if base_table_rows:
-            df = pd.DataFrame(base_table_rows, columns=['Table Number', 'Land Cover Name', 'Base Manning\'s n Value'])
+            df = pd.DataFrame(base_table_rows, columns=['Table Number', 'Land Cover Name', 'Base Mannings n Value'])
             return df
         else:
-            return pd.DataFrame(columns=['Table Number', 'Land Cover Name', 'Base Manning\'s n Value'])
+            return pd.DataFrame(columns=['Table Number', 'Land Cover Name', 'Base Mannings n Value'])
 
 
     @staticmethod

ras_commander/RasMap.py

@@ -1,252 +1,467 @@
-"""
-RasMap - Parses HEC-RAS mapper configuration files (.rasmap)
-
-This module provides functionality to extract and organize information from 
-HEC-RAS mapper configuration files, including paths to terrain, soil, and land cover data.
-
-This module is part of the ras-commander library and uses a centralized logging configuration.
-
-Logging Configuration:
-- The logging is set up in the logging_config.py file.
-- A @log_call decorator is available to automatically log function calls.
-- Log levels: DEBUG, INFO, WARNING, ERROR, CRITICAL
-
-Classes:
-    RasMap: Class for parsing and accessing HEC-RAS mapper configuration.
-"""
-
-import os
-import re
-import xml.etree.ElementTree as ET
-from pathlib import Path
-import pandas as pd
-from typing import Union, Optional, Dict, List, Any
-
-from .RasPrj import ras
-from .LoggingConfig import get_logger
-from .Decorators import log_call
-
-logger = get_logger(__name__)
-
-class RasMap:
-    """
-    Class for parsing and accessing information from HEC-RAS mapper configuration files (.rasmap).
-    
-    This class provides methods to extract paths to terrain, soil, land cover data,
-    and various project settings from the .rasmap file associated with a HEC-RAS project.
-    """
-    
-    @staticmethod
-    @log_call
-    def parse_rasmap(rasmap_path: Union[str, Path], ras_object=None) -> pd.DataFrame:
-        """
-        Parse a .rasmap file and extract relevant information.
-        
-        Args:
-            rasmap_path (Union[str, Path]): Path to the .rasmap file.
-            ras_object: Optional RAS object instance.
-            
-        Returns:
-            pd.DataFrame: DataFrame containing extracted information from the .rasmap file.
-        """
-        ras_obj = ras_object or ras
-        ras_obj.check_initialized()
-        
-        rasmap_path = Path(rasmap_path)
-        if not rasmap_path.exists():
-            logger.error(f"RASMapper file not found: {rasmap_path}")
-            # Create a single row DataFrame with all empty values
-            return pd.DataFrame({
-                'projection_path': [None],
-                'profile_lines_path': [[]],
-                'soil_layer_path': [[]],
-                'infiltration_hdf_path': [[]],
-                'landcover_hdf_path': [[]],
-                'terrain_hdf_path': [[]],
-                'current_settings': [{}]
-            })
-        
-        try:
-            # Initialize data for the DataFrame - just one row with lists
-            data = {
-                'projection_path': [None],
-                'profile_lines_path': [[]],
-                'soil_layer_path': [[]],
-                'infiltration_hdf_path': [[]],
-                'landcover_hdf_path': [[]],
-                'terrain_hdf_path': [[]],
-                'current_settings': [{}]
-            }
-            
-            # Read the file content
-            with open(rasmap_path, 'r', encoding='utf-8') as f:
-                xml_content = f.read()
-            
-            # Check if it's a valid XML file
-            if not xml_content.strip().startswith('<'):
-                logger.error(f"File does not appear to be valid XML: {rasmap_path}")
-                return pd.DataFrame(data)
-            
-            # Parse the XML file
-            try:
-                tree = ET.parse(rasmap_path)
-                root = tree.getroot()
-            except ET.ParseError as e:
-                logger.error(f"Error parsing XML in {rasmap_path}: {e}")
-                return pd.DataFrame(data)
-            
-            # Helper function to convert relative paths to absolute paths
-            def to_absolute_path(relative_path: str) -> str:
-                if not relative_path:
-                    return None
-                # Remove any leading .\ or ./
-                relative_path = relative_path.lstrip('.\\').lstrip('./')
-                # Convert to absolute path relative to project folder
-                return str(ras_obj.project_folder / relative_path)
-            
-            # Extract projection path
-            try:
-                projection_elem = root.find(".//RASProjectionFilename")
-                if projection_elem is not None and 'Filename' in projection_elem.attrib:
-                    data['projection_path'][0] = to_absolute_path(projection_elem.attrib['Filename'])
-            except Exception as e:
-                logger.warning(f"Error extracting projection path: {e}")
-            
-            # Extract profile lines path
-            try:
-                profile_lines_elem = root.find(".//Features/Layer[@Name='Profile Lines']")
-                if profile_lines_elem is not None and 'Filename' in profile_lines_elem.attrib:
-                    data['profile_lines_path'][0].append(to_absolute_path(profile_lines_elem.attrib['Filename']))
-            except Exception as e:
-                logger.warning(f"Error extracting profile lines path: {e}")
-            
-            # Extract soil layer paths
-            try:
-                soil_layers = root.findall(".//Layer[@Name='Hydrologic Soil Groups']")
-                for layer in soil_layers:
-                    if 'Filename' in layer.attrib:
-                        data['soil_layer_path'][0].append(to_absolute_path(layer.attrib['Filename']))
-            except Exception as e:
-                logger.warning(f"Error extracting soil layer paths: {e}")
-            
-            # Extract infiltration HDF paths
-            try:
-                infiltration_layers = root.findall(".//Layer[@Name='Infiltration']")
-                for layer in infiltration_layers:
-                    if 'Filename' in layer.attrib:
-                        data['infiltration_hdf_path'][0].append(to_absolute_path(layer.attrib['Filename']))
-            except Exception as e:
-                logger.warning(f"Error extracting infiltration HDF paths: {e}")
-            
-            # Extract landcover HDF paths
-            try:
-                landcover_layers = root.findall(".//Layer[@Name='LandCover']")
-                for layer in landcover_layers:
-                    if 'Filename' in layer.attrib:
-                        data['landcover_hdf_path'][0].append(to_absolute_path(layer.attrib['Filename']))
-            except Exception as e:
-                logger.warning(f"Error extracting landcover HDF paths: {e}")
-            
-            # Extract terrain HDF paths
-            try:
-                terrain_layers = root.findall(".//Terrains/Layer")
-                for layer in terrain_layers:
-                    if 'Filename' in layer.attrib:
-                        data['terrain_hdf_path'][0].append(to_absolute_path(layer.attrib['Filename']))
-            except Exception as e:
-                logger.warning(f"Error extracting terrain HDF paths: {e}")
-            
-            # Extract current settings
-            current_settings = {}
-            try:
-                settings_elem = root.find(".//CurrentSettings")
-                if settings_elem is not None:
-                    # Extract ProjectSettings
-                    project_settings_elem = settings_elem.find("ProjectSettings")
-                    if project_settings_elem is not None:
-                        for child in project_settings_elem:
-                            current_settings[child.tag] = child.text
-                    
-                    # Extract Folders
-                    folders_elem = settings_elem.find("Folders")
-                    if folders_elem is not None:
-                        for child in folders_elem:
-                            current_settings[child.tag] = child.text
-                            
-                data['current_settings'][0] = current_settings
-            except Exception as e:
-                logger.warning(f"Error extracting current settings: {e}")
-            
-            # Create DataFrame
-            df = pd.DataFrame(data)
-            logger.info(f"Successfully parsed RASMapper file: {rasmap_path}")
-            return df
-            
-        except Exception as e:
-            logger.error(f"Unexpected error processing RASMapper file {rasmap_path}: {e}")
-            # Create a single row DataFrame with all empty values
-            return pd.DataFrame({
-                'projection_path': [None],
-                'profile_lines_path': [[]],
-                'soil_layer_path': [[]],
-                'infiltration_hdf_path': [[]],
-                'landcover_hdf_path': [[]],
-                'terrain_hdf_path': [[]],
-                'current_settings': [{}]
-            })
-    
-    @staticmethod
-    @log_call
-    def get_rasmap_path(ras_object=None) -> Optional[Path]:
-        """
-        Get the path to the .rasmap file based on the current project.
-        
-        Args:
-            ras_object: Optional RAS object instance.
-            
-        Returns:
-            Optional[Path]: Path to the .rasmap file if found, None otherwise.
-        """
-        ras_obj = ras_object or ras
-        ras_obj.check_initialized()
-        
-        project_name = ras_obj.project_name
-        project_folder = ras_obj.project_folder
-        rasmap_path = project_folder / f"{project_name}.rasmap"
-        
-        if not rasmap_path.exists():
-            logger.warning(f"RASMapper file not found: {rasmap_path}")
-            return None
-        
-        return rasmap_path
-    
-    @staticmethod
-    @log_call
-    def initialize_rasmap_df(ras_object=None) -> pd.DataFrame:
-        """
-        Initialize the rasmap_df as part of project initialization.
-        
-        Args:
-            ras_object: Optional RAS object instance.
-            
-        Returns:
-            pd.DataFrame: DataFrame containing information from the .rasmap file.
-        """
-        ras_obj = ras_object or ras
-        ras_obj.check_initialized()
-        
-        rasmap_path = RasMap.get_rasmap_path(ras_obj)
-        if rasmap_path is None:
-            logger.warning("No .rasmap file found for this project. Creating empty rasmap_df.")
-            # Create a single row DataFrame with all empty values
-            return pd.DataFrame({
-                'projection_path': [None],
-                'profile_lines_path': [[]],
-                'soil_layer_path': [[]],
-                'infiltration_hdf_path': [[]],
-                'landcover_hdf_path': [[]],
-                'terrain_hdf_path': [[]],
-                'current_settings': [{}]
-            })
-        
-        return RasMap.parse_rasmap(rasmap_path, ras_obj)
+"""
+RasMap - Parses HEC-RAS mapper configuration files (.rasmap)
+
+This module provides functionality to extract and organize information from 
+HEC-RAS mapper configuration files, including paths to terrain, soil, and land cover data.
+It also includes functions to automate the post-processing of stored maps.
+
+This module is part of the ras-commander library and uses a centralized logging configuration.
+
+Logging Configuration:
+- The logging is set up in the logging_config.py file.
+- A @log_call decorator is available to automatically log function calls.
+- Log levels: DEBUG, INFO, WARNING, ERROR, CRITICAL
+
+Classes:
+    RasMap: Class for parsing and accessing HEC-RAS mapper configuration.
+"""
+
+import os
+import re
+import xml.etree.ElementTree as ET
+from pathlib import Path
+import pandas as pd
+import shutil
+from typing import Union, Optional, Dict, List, Any
+
+from .RasPrj import ras
+from .RasPlan import RasPlan
+from .RasCmdr import RasCmdr
+from .LoggingConfig import get_logger
+from .Decorators import log_call
+
+logger = get_logger(__name__)
+
+class RasMap:
+    """
+    Class for parsing and accessing information from HEC-RAS mapper configuration files (.rasmap).
+    
+    This class provides methods to extract paths to terrain, soil, land cover data,
+    and various project settings from the .rasmap file associated with a HEC-RAS project.
+    It also includes functionality to automate the post-processing of stored maps.
+    """
+    
+    @staticmethod
+    @log_call
+    def parse_rasmap(rasmap_path: Union[str, Path], ras_object=None) -> pd.DataFrame:
+        """
+        Parse a .rasmap file and extract relevant information.
+        
+        Args:
+            rasmap_path (Union[str, Path]): Path to the .rasmap file.
+            ras_object: Optional RAS object instance.
+            
+        Returns:
+            pd.DataFrame: DataFrame containing extracted information from the .rasmap file.
+        """
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+        
+        rasmap_path = Path(rasmap_path)
+        if not rasmap_path.exists():
+            logger.error(f"RASMapper file not found: {rasmap_path}")
+            # Create a single row DataFrame with all empty values
+            return pd.DataFrame({
+                'projection_path': [None],
+                'profile_lines_path': [[]],
+                'soil_layer_path': [[]],
+                'infiltration_hdf_path': [[]],
+                'landcover_hdf_path': [[]],
+                'terrain_hdf_path': [[]],
+                'current_settings': [{}]
+            })
+        
+        try:
+            # Initialize data for the DataFrame - just one row with lists
+            data = {
+                'projection_path': [None],
+                'profile_lines_path': [[]],
+                'soil_layer_path': [[]],
+                'infiltration_hdf_path': [[]],
+                'landcover_hdf_path': [[]],
+                'terrain_hdf_path': [[]],
+                'current_settings': [{}]
+            }
+            
+            # Read the file content
+            with open(rasmap_path, 'r', encoding='utf-8') as f:
+                xml_content = f.read()
+            
+            # Check if it's a valid XML file
+            if not xml_content.strip().startswith('<'):
+                logger.error(f"File does not appear to be valid XML: {rasmap_path}")
+                return pd.DataFrame(data)
+            
+            # Parse the XML file
+            try:
+                tree = ET.parse(rasmap_path)
+                root = tree.getroot()
+            except ET.ParseError as e:
+                logger.error(f"Error parsing XML in {rasmap_path}: {e}")
+                return pd.DataFrame(data)
+            
+            # Helper function to convert relative paths to absolute paths
+            def to_absolute_path(relative_path: str) -> str:
+                if not relative_path:
+                    return None
+                # Remove any leading .\ or ./
+                relative_path = relative_path.lstrip('.\\').lstrip('./')
+                # Convert to absolute path relative to project folder
+                return str(ras_obj.project_folder / relative_path)
+            
+            # Extract projection path
+            try:
+                projection_elem = root.find(".//RASProjectionFilename")
+                if projection_elem is not None and 'Filename' in projection_elem.attrib:
+                    data['projection_path'][0] = to_absolute_path(projection_elem.attrib['Filename'])
+            except Exception as e:
+                logger.warning(f"Error extracting projection path: {e}")
+            
+            # Extract profile lines path
+            try:
+                profile_lines_elem = root.find(".//Features/Layer[@Name='Profile Lines']")
+                if profile_lines_elem is not None and 'Filename' in profile_lines_elem.attrib:
+                    data['profile_lines_path'][0].append(to_absolute_path(profile_lines_elem.attrib['Filename']))
+            except Exception as e:
+                logger.warning(f"Error extracting profile lines path: {e}")
+            
+            # Extract soil layer paths
+            try:
+                soil_layers = root.findall(".//Layer[@Name='Hydrologic Soil Groups']")
+                for layer in soil_layers:
+                    if 'Filename' in layer.attrib:
+                        data['soil_layer_path'][0].append(to_absolute_path(layer.attrib['Filename']))
+            except Exception as e:
+                logger.warning(f"Error extracting soil layer paths: {e}")
+            
+            # Extract infiltration HDF paths
+            try:
+                infiltration_layers = root.findall(".//Layer[@Name='Infiltration']")
+                for layer in infiltration_layers:
+                    if 'Filename' in layer.attrib:
+                        data['infiltration_hdf_path'][0].append(to_absolute_path(layer.attrib['Filename']))
+            except Exception as e:
+                logger.warning(f"Error extracting infiltration HDF paths: {e}")
+            
+            # Extract landcover HDF paths
+            try:
+                landcover_layers = root.findall(".//Layer[@Name='LandCover']")
+                for layer in landcover_layers:
+                    if 'Filename' in layer.attrib:
+                        data['landcover_hdf_path'][0].append(to_absolute_path(layer.attrib['Filename']))
+            except Exception as e:
+                logger.warning(f"Error extracting landcover HDF paths: {e}")
+            
+            # Extract terrain HDF paths
+            try:
+                terrain_layers = root.findall(".//Terrains/Layer")
+                for layer in terrain_layers:
+                    if 'Filename' in layer.attrib:
+                        data['terrain_hdf_path'][0].append(to_absolute_path(layer.attrib['Filename']))
+            except Exception as e:
+                logger.warning(f"Error extracting terrain HDF paths: {e}")
+            
+            # Extract current settings
+            current_settings = {}
+            try:
+                settings_elem = root.find(".//CurrentSettings")
+                if settings_elem is not None:
+                    # Extract ProjectSettings
+                    project_settings_elem = settings_elem.find("ProjectSettings")
+                    if project_settings_elem is not None:
+                        for child in project_settings_elem:
+                            current_settings[child.tag] = child.text
+                    
+                    # Extract Folders
+                    folders_elem = settings_elem.find("Folders")
+                    if folders_elem is not None:
+                        for child in folders_elem:
+                            current_settings[child.tag] = child.text
+                            
+                data['current_settings'][0] = current_settings
+            except Exception as e:
+                logger.warning(f"Error extracting current settings: {e}")
+            
+            # Create DataFrame
+            df = pd.DataFrame(data)
+            logger.info(f"Successfully parsed RASMapper file: {rasmap_path}")
+            return df
+            
+        except Exception as e:
+            logger.error(f"Unexpected error processing RASMapper file {rasmap_path}: {e}")
+            # Create a single row DataFrame with all empty values
+            return pd.DataFrame({
+                'projection_path': [None],
+                'profile_lines_path': [[]],
+                'soil_layer_path': [[]],
+                'infiltration_hdf_path': [[]],
+                'landcover_hdf_path': [[]],
+                'terrain_hdf_path': [[]],
+                'current_settings': [{}]
+            })
+    
+    @staticmethod
+    @log_call
+    def get_rasmap_path(ras_object=None) -> Optional[Path]:
+        """
+        Get the path to the .rasmap file based on the current project.
+        
+        Args:
+            ras_object: Optional RAS object instance.
+            
+        Returns:
+            Optional[Path]: Path to the .rasmap file if found, None otherwise.
+        """
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+        
+        project_name = ras_obj.project_name
+        project_folder = ras_obj.project_folder
+        rasmap_path = project_folder / f"{project_name}.rasmap"
+        
+        if not rasmap_path.exists():
+            logger.warning(f"RASMapper file not found: {rasmap_path}")
+            return None
+        
+        return rasmap_path
+    
+    @staticmethod
+    @log_call
+    def initialize_rasmap_df(ras_object=None) -> pd.DataFrame:
+        """
+        Initialize the rasmap_df as part of project initialization.
+        
+        Args:
+            ras_object: Optional RAS object instance.
+            
+        Returns:
+            pd.DataFrame: DataFrame containing information from the .rasmap file.
+        """
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+        
+        rasmap_path = RasMap.get_rasmap_path(ras_obj)
+        if rasmap_path is None:
+            logger.warning("No .rasmap file found for this project. Creating empty rasmap_df.")
+            # Create a single row DataFrame with all empty values
+            return pd.DataFrame({
+                'projection_path': [None],
+                'profile_lines_path': [[]],
+                'soil_layer_path': [[]],
+                'infiltration_hdf_path': [[]],
+                'landcover_hdf_path': [[]],
+                'terrain_hdf_path': [[]],
+                'current_settings': [{}]
+            })
+        
+        return RasMap.parse_rasmap(rasmap_path, ras_obj)
+
+    @staticmethod
+    @log_call
+    def get_terrain_names(rasmap_path: Union[str, Path]) -> List[str]:
+        """
+        Extracts terrain layer names from a given .rasmap file.
+        
+        Args:
+            rasmap_path (Union[str, Path]): Path to the .rasmap file.
+
+        Returns:
+            List[str]: A list of terrain names.
+        
+        Raises:
+            FileNotFoundError: If the rasmap file does not exist.
+            ValueError: If the file is not a valid XML or lacks a 'Terrains' section.
+        """
+        rasmap_path = Path(rasmap_path)
+        if not rasmap_path.is_file():
+            raise FileNotFoundError(f"The file '{rasmap_path}' does not exist.")
+
+        try:
+            tree = ET.parse(rasmap_path)
+            root = tree.getroot()
+        except ET.ParseError as e:
+            raise ValueError(f"Failed to parse the RASMAP file. Ensure it is a valid XML file. Error: {e}")
+
+        terrains_element = root.find('Terrains')
+        if terrains_element is None:
+            logger.warning("The RASMAP file does not contain a 'Terrains' section.")
+            return []
+
+        terrain_names = [layer.get('Name') for layer in terrains_element.findall('Layer') if layer.get('Name')]
+        logger.info(f"Extracted terrain names: {terrain_names}")
+        return terrain_names
+
+
+    @staticmethod
+    @log_call
+    def postprocess_stored_maps(
+        plan_number: Union[str, List[str]],
+        specify_terrain: Optional[str] = None,
+        layers: Union[str, List[str]] = None,
+        ras_object: Optional[Any] = None
+    ) -> bool:
+        """
+        Automates the generation of stored floodplain map outputs (e.g., .tif files).
+
+        This function modifies the plan and .rasmap files to generate floodplain maps
+        for one or more plans, then restores the original files.
+
+        Args:
+            plan_number (Union[str, List[str]]): Plan number(s) to generate maps for.
+            specify_terrain (Optional[str]): The name of a specific terrain to use.
+            layers (Union[str, List[str]], optional): A list of map layers to generate.
+                Defaults to ['WSEL', 'Velocity', 'Depth'].
+            ras_object (Optional[Any]): The RAS project object.
+
+        Returns:
+            bool: True if the process completed successfully, False otherwise.
+        """
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+
+        if layers is None:
+            layers = ['WSEL', 'Velocity', 'Depth']
+        elif isinstance(layers, str):
+            layers = [layers]
+
+        # Convert plan_number to list if it's a string
+        plan_number_list = [plan_number] if isinstance(plan_number, str) else plan_number
+
+        rasmap_path = ras_obj.project_folder / f"{ras_obj.project_name}.rasmap"
+        rasmap_backup_path = rasmap_path.with_suffix(f"{rasmap_path.suffix}.storedmap.bak")
+
+        # Store plan paths and their backups
+        plan_paths = []
+        plan_backup_paths = []
+        for plan_num in plan_number_list:
+            plan_path = Path(RasPlan.get_plan_path(plan_num, ras_obj))
+            plan_backup_path = plan_path.with_suffix(f"{plan_path.suffix}.storedmap.bak")
+            plan_paths.append(plan_path)
+            plan_backup_paths.append(plan_backup_path)
+
+        def _create_map_element(name, map_type, profile_name="Max"):
+            map_params = {
+                "MapType": map_type,
+                "OutputMode": "Stored Current Terrain",
+                "ProfileIndex": "2147483647",
+                "ProfileName": profile_name
+            }
+            if specify_terrain:
+                map_params["Terrain"] = specify_terrain
+            
+            layer_elem = ET.Element('Layer', Name=name, Type="RASResultsMap", Checked="True")
+            map_params_elem = ET.SubElement(layer_elem, 'MapParameters')
+            for k, v in map_params.items():
+                map_params_elem.set(k, str(v))
+            return layer_elem
+
+        try:
+            # --- 1. Backup and Modify Plan Files ---
+            for plan_num, plan_path, plan_backup_path in zip(plan_number_list, plan_paths, plan_backup_paths):
+                logger.info(f"Backing up plan file {plan_path} to {plan_backup_path}")
+                shutil.copy2(plan_path, plan_backup_path)
+                
+                logger.info(f"Updating plan run flags for floodplain mapping for plan {plan_num}...")
+                RasPlan.update_run_flags(
+                    plan_num,
+                    geometry_preprocessor=False,
+                    unsteady_flow_simulation=False,
+                    post_processor=False,
+                    floodplain_mapping=True, # Note: True maps to 0, which means "Run"
+                    ras_object=ras_obj
+                )
+
+            # --- 2. Backup and Modify RASMAP File ---
+            logger.info(f"Backing up rasmap file {rasmap_path} to {rasmap_backup_path}")
+            shutil.copy2(rasmap_path, rasmap_backup_path)
+
+            tree = ET.parse(rasmap_path)
+            root = tree.getroot()
+            
+            results_section = root.find('Results')
+            if results_section is None:
+                raise ValueError(f"No <Results> section found in {rasmap_path}")
+
+            # Process each plan's results layer
+            for plan_num in plan_number_list:
+                plan_hdf_part = f".p{plan_num}.hdf"
+                results_layer = None
+                for layer in results_section.findall("Layer[@Type='RASResults']"):
+                    filename = layer.get("Filename")
+                    if filename and plan_hdf_part.lower() in filename.lower():
+                        results_layer = layer
+                        break
+
+                if results_layer is None:
+                    logger.warning(f"Could not find RASResults layer for plan ending in '{plan_hdf_part}' in {rasmap_path}")
+                    continue
+                
+                map_definitions = {"WSEL": "elevation", "Velocity": "velocity", "Depth": "depth"}
+                for layer_name in layers:
+                    if layer_name in map_definitions:
+                        map_type = map_definitions[layer_name]
+                        layername_attr = "Water Surface" if layer_name == "WSEL" else None
+                        map_elem = _create_map_element(layer_name, map_type)
+                        if layername_attr:
+                            map_elem.find("MapParameters").set("LayerName", layername_attr)
+                        results_layer.append(map_elem)
+                        logger.info(f"Added '{layer_name}' stored map to results layer for plan {plan_num}.")
+
+            if specify_terrain:
+                terrains_elem = root.find('Terrains')
+                if terrains_elem is not None:
+                    for layer in list(terrains_elem):
+                        if layer.get('Name') != specify_terrain:
+                            terrains_elem.remove(layer)
+                    logger.info(f"Filtered terrains, keeping only '{specify_terrain}'.")
+
+            tree.write(rasmap_path, encoding='utf-8', xml_declaration=True)
+            
+            # --- 3. Execute HEC-RAS ---
+            logger.info("Opening HEC-RAS...")
+            ras_exe = ras_obj.ras_exe_path
+            prj_path = f'"{str(ras_obj.prj_file)}"'
+            command = f"{ras_exe} {prj_path}"
+            
+            try:
+                import sys
+                import subprocess
+                if sys.platform == "win32":
+                    hecras_process = subprocess.Popen(command)
+                else:
+                    hecras_process = subprocess.Popen([ras_exe, prj_path])
+
+                logger.info(f"HEC-RAS opened with Process ID: {hecras_process.pid}")
+                logger.info(f"Please run plan(s) {', '.join(plan_number_list)} using the 'Compute Multiple' window in HEC-RAS to generate floodplain mapping results.")
+                
+                # Wait for HEC-RAS to close
+                logger.info("Waiting for HEC-RAS to close...")
+                hecras_process.wait()
+                logger.info("HEC-RAS has closed")
+                
+                success = True
+
+            except Exception as e:
+                logger.error(f"Failed to launch HEC-RAS: {e}")
+                success = False
+
+            if not success:
+                logger.error("Floodplain mapping computation failed.")
+                return False
+
+            logger.info("Floodplain mapping computation successful.")
+            return True
+        
+        except Exception as e:
+            logger.error(f"Error in postprocess_stored_maps: {e}")
+            return False
+
+        finally:
+            # --- 4. Restore Files ---
+            for plan_path, plan_backup_path in zip(plan_paths, plan_backup_paths):
+                if plan_backup_path.exists():
+                    logger.info(f"Restoring original plan file from {plan_backup_path}")
+                    shutil.move(plan_backup_path, plan_path)
+            if rasmap_backup_path.exists():
+                logger.info(f"Restoring original rasmap file from {rasmap_backup_path}")
+                shutil.move(rasmap_backup_path, rasmap_path)

ras_commander/RasPrj.py

@@ -1295,7 +1295,8 @@ def init_ras_project(ras_project_folder, ras_version=None, ras_object=None):
         >>> my_project = init_ras_project("/path/to/project", "6.6", "new")
         >>> print(f"Created project instance: {my_project.project_name}")
     """
-    project_folder = Path(ras_project_folder)
+    # Convert to absolute path immediately to ensure consistent path handling
+    project_folder = Path(ras_project_folder).resolve()
     if not project_folder.exists():
         logger.error(f"The specified RAS project folder does not exist: {project_folder}")
         raise FileNotFoundError(f"The specified RAS project folder does not exist: {project_folder}. Please check the path and try again.")

{ras_commander-0.77.0.dist-info → ras_commander-0.78.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ras-commander
-Version: 0.77.0
+Version: 0.78.0
 Summary: A Python library for automating HEC-RAS 6.x operations
 Home-page: https://github.com/gpt-cmdr/ras-commander
 Author: William M. Katzenmeyer, P.E., C.F.M.
@@ -291,7 +291,7 @@ This is useful for comparing different river systems, running scenario analyses
 - `RasGeo`: Handles operations related to geometry files
 - `RasUnsteady`: Manages unsteady flow file operations
 - `RasUtils`: Contains utility functions for file operations and data management
-- `RasMap`: Parses and manages RASMapper configuration data
+- `RasMap`: Parses RASMapper configuration files and automates floodplain mapping
 - `RasExamples`: Manages and loads HEC-RAS example projects
 
 #### HDF Data Access Classes
@@ -511,7 +511,6 @@ Additionally, we would like to acknowledge the following notable contributions a
 
 - Development of additional HDF functions for detailed analysis and mapping of HEC-RAS results within the RasHdf class.
 - Development of the prototype `RasCmdr` class for executing HEC-RAS simulations.
-- Optimization examples and methods from (INSERT REFERENCE) for use in the Ras-Commander library examples
 
 2. Attribution: The [`pyHMT2D`](https://github.com/psu-efd/pyHMT2D/) project by Xiaofeng Liu, which provided insights into HDF file handling methods for HEC-RAS outputs.  Many of the functions in the [Ras_2D_Data.py](https://github.com/psu-efd/pyHMT2D/blob/main/pyHMT2D/Hydraulic_Models_Data/RAS_2D/RAS_2D_Data.py) file were adapted with AI for use in RAS Commander. 
 

{ras_commander-0.77.0.dist-info → ras_commander-0.78.0.dist-info}/RECORD

@@ -17,16 +17,16 @@ ras_commander/HdfUtils.py,sha256=VkIKAXBrLwTlk2VtXSO-W3RU-NHpfHbE1QcZUZgl-t8,152
 ras_commander/HdfXsec.py,sha256=flREnFFrIZu4SSKGRQeX9w3SS49q0UWPJnq4zO7DbUM,27342
 ras_commander/LoggingConfig.py,sha256=gWe5K5XTmMQpSczsTysAqpC9my24i_IyM8dvD85fxYg,2704
 ras_commander/RasCmdr.py,sha256=37GnchoQ0fIAkPnssnCr1mRUXY8gm-hIMTmuHZlnYP8,34591
-ras_commander/RasExamples.py,sha256=9CxqIB8GwA5o81p-N8vu93kxGMOZLQBfrOb58DGjEHQ,17959
-ras_commander/RasGeo.py,sha256=Yiqnbl2L-W_UeT-x-ZHrNKKJ6kIxLyxpfx2fzxleB8s,21675
-ras_commander/RasMap.py,sha256=4cVzaaQure-CXdXB1BY29iE20S00eldUqoL96PvJPbw,10635
+ras_commander/RasExamples.py,sha256=oOI9id_98anyrTqqpnYbbs5VX7q1E0P-cC4wzqT3OTg,23411
+ras_commander/RasGeo.py,sha256=u2HUkFrPnMc6Z7jD4PHM4YV3nwTZqMi4QIoNDQ7Rjug,21671
+ras_commander/RasMap.py,sha256=OqUaMmNRw6opVBxkCAYd--pEE1gZE-Y5SPyoaX2ulMg,19791
 ras_commander/RasPlan.py,sha256=ogIpLqawXTsjLnKRZTqzZydn_EFVJZFZZGgHvJ_t_-c,65408
-ras_commander/RasPrj.py,sha256=ab10DeR11_edA54vL1DOptVXlIHNxLXOX6hN8I_Xr3M,63359
+ras_commander/RasPrj.py,sha256=oXPWuNC_403mUfqyysXyBVul0Xtz_0SKDxZdj4fvNYU,63448
 ras_commander/RasUnsteady.py,sha256=TO08CT2GC4G5rcXO_Wbia2t4PhiWRu9-nC9F0IW7Gyo,37187
 ras_commander/RasUtils.py,sha256=0fm4IIs0LH1dgDj3pGd66mR82DhWLEkRKUvIo2M_5X0,35886
 ras_commander/__init__.py,sha256=byL-4pG2AwLeZXa1nFd3srZe9Pu96V52Y5Dujcu3mM8,2039
-ras_commander-0.77.0.dist-info/licenses/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
-ras_commander-0.77.0.dist-info/METADATA,sha256=WHdVmyFOjbMEAmtHOxWbAWEUt7fSvsNlffXpCkfrRxw,27940
-ras_commander-0.77.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-ras_commander-0.77.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
-ras_commander-0.77.0.dist-info/RECORD,,
+ras_commander-0.78.0.dist-info/licenses/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
+ras_commander-0.78.0.dist-info/METADATA,sha256=-AIKb7auKcOkGb6vDogfaKr4eCdhFZIrml4kPiZbpcM,27855
+ras_commander-0.78.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ras_commander-0.78.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
+ras_commander-0.78.0.dist-info/RECORD,,

{ras_commander-0.77.0.dist-info → ras_commander-0.78.0.dist-info}/WHEEL

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