ras-commander 0.71.0__py3-none-any.whl → 0.73.0__py3-none-any.whl

ras_commander/RasMap.py

@@ -0,0 +1,252 @@
+"""
+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)

ras_commander/RasPrj.py

@@ -137,13 +137,14 @@ class RasPrj:
             2. Loading project data (plans, geometries, flows)
             3. Extracting boundary conditions
             4. Setting the initialization flag
+            5. Loading RASMapper data (.rasmap)
         """
         self.suppress_logging = suppress_logging  # Store suppress_logging state
         self.project_folder = Path(project_folder)
         self.prj_file = self.find_ras_prj(self.project_folder)
         if self.prj_file is None:
             logger.error(f"No HEC-RAS project file found in {self.project_folder}")
-            raise ValueError(f"No HEC-RAS project file found in {self.project_folder}")
+            raise ValueError(f"No HEC-RAS project file found in {self.project_folder}. Please check the path and try again.")
         self.project_name = Path(self.prj_file).stem
         self.ras_exe_path = ras_exe_path
         
@@ -153,6 +154,22 @@ class RasPrj:
         # Now load the project data
         self._load_project_data()
         self.boundaries_df = self.get_boundary_conditions()
+        
+        # Load RASMapper data if available
+        try:
+            # Import here to avoid circular imports
+            from .RasMap import RasMap
+            self.rasmap_df = RasMap.initialize_rasmap_df(self)
+        except ImportError:
+            logger.warning("RasMap module not available. RASMapper data will not be loaded.")
+            self.rasmap_df = pd.DataFrame(columns=['projection_path', 'profile_lines_path', 'soil_layer_path', 
+                                                'infiltration_hdf_path', 'landcover_hdf_path', 'terrain_hdf_path', 
+                                                'current_settings'])
+        except Exception as e:
+            logger.error(f"Error initializing RASMapper data: {e}")
+            self.rasmap_df = pd.DataFrame(columns=['projection_path', 'profile_lines_path', 'soil_layer_path', 
+                                                'infiltration_hdf_path', 'landcover_hdf_path', 'terrain_hdf_path', 
+                                                'current_settings'])
 
         if not suppress_logging:
             logger.info(f"Initialization complete for project: {self.project_name}")
@@ -160,6 +177,7 @@ class RasPrj:
                          f"Unsteady entries: {len(self.unsteady_df)}, Geometry entries: {len(self.geom_df)}, "
                          f"Boundary conditions: {len(self.boundaries_df)}")
             logger.info(f"Geometry HDF files found: {self.plan_df['Geom_File'].notna().sum()}")
+            logger.info(f"RASMapper data loaded: {not self.rasmap_df.empty}")
 
     @log_call
     def _load_project_data(self):

ras_commander/__init__.py

@@ -10,7 +10,7 @@ try:
     __version__ = version("ras-commander")
 except PackageNotFoundError:
     # package is not installed
-    __version__ = "0.71.0"
+    __version__ = "0.73.0"
 
 # Set up logging
 setup_logging()
@@ -23,6 +23,7 @@ from .RasUnsteady import RasUnsteady
 from .RasUtils import RasUtils
 from .RasExamples import RasExamples
 from .RasCmdr import RasCmdr
+from .RasMap import RasMap
 from .HdfFluvialPluvial import HdfFluvialPluvial
 
 # HDF handling
@@ -49,7 +50,7 @@ __all__ = [
     # Core functionality
     'RasPrj', 'init_ras_project', 'get_ras_exe', 'ras',
     'RasPlan', 'RasGeo', 'RasUnsteady', 'RasUtils',
-    'RasExamples', 'RasCmdr', 'HdfFluvialPluvial',
+    'RasExamples', 'RasCmdr', 'RasMap', 'HdfFluvialPluvial',
     
     # HDF handling
     'HdfBase', 'HdfBndry', 'HdfMesh', 'HdfPlan',

{ras_commander-0.71.0.dist-info → ras_commander-0.73.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ras-commander
-Version: 0.71.0
+Version: 0.73.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.
@@ -59,7 +59,7 @@ This repository has several methods of interaction with Large Language Models an
 The RAS-Commander library Assistant is a full-featured interface for multi-turn conversations, using your own API keys and the ras-commander library for context. The library assistant allows you to load your own scripts and chat with specific examples and/or function classes in the RAS-Commander library to effectively utilize the library's functions in your workflow. To reduce hallucinations, a file browser is included which adds full files to the conversation to ensure grounded responses. A dashboard shows you the total context and estimated cost of each request. **Now with support for Claude 3.7, OpenAI's o1 and o3-mini, and Deepseek V3 and R1 models using US-based Together.ai, and available as a standalone windows executable that runs within the repository**
 
 
-8. **[RAS Commander Library Assistant on ChatGPT](https://chatgpt.com/g/g-TZRPR3oAO-ras-commander-library-assistant)**: A specialized ChatGPT "GPT" with access to the ras-commander codebase and library, available for answering queries and providing code suggestions.   You can even upload your own plan, unsteady and HDF files to inspect and help determine how to automate your workflows or visualize your results.  _NOTE: GPT's are still quite limited by OpenAI's GPT frameworks and may not be useful for long conversations.  Code interpreter cannot run HEC-RAS but can open and view smaller HDF files and projects for demonstration purposes_
+8. **[RAS Commander Library Assistant on ChatGPT](https://chatgpt.com/g/g-TZRPR3oAO-ras-commander-library-assistant)**: A specialized ChatGPT "GPT" with access to the ras-commander codebase and library, available for answering queries and providing code suggestions.   You can even upload your own plan, unsteady and HDF files to inspect and help determine how to automate your workflows or visualize your results.  _NOTE: GPT's are still quite limited by OpenAI's GPT frameworks and may not be useful for long conversations.  Code interpreter cannot run HEC-RAS but can [open and view smaller HDF files and projects for demonstration purposes](https://chatgpt.com/share/67e7cdb7-49e0-8010-bbac-61d2c54d473f)_
 
 
 ## Background
@@ -85,6 +85,25 @@ HDF Data Access & Analysis
 - Pipe network and pump station analysis
 - Fluvial-pluvial boundary calculations
 - Infiltration and precipitation data handling
+- Infiltration and soil data handling
+- Land cover and terrain data integration
+- Weighted parameter calculations for hydrologic modeling
+
+RASMapper Data Integration
+- RASMapper configuration parsing (.rasmap files)
+- Terrain, soil, and land cover HDF paths
+- Profile line paths
+
+Manning's n Coefficient Management
+- Base Manning's n table extraction and modification
+- Regional overrides for spatially-varied roughness
+- Direct editing of geometry file Manning values
+
+Infiltration & Soil Analysis
+- Soil statistics calculation and analysis
+- Infiltration parameter management and scaling
+- Weighted average parameter calculation
+- Raster-based soil data processing
 
 RAS ASCII File Operations
 - Plan file creation and modification
@@ -266,6 +285,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
 - `RasExamples`: Manages and loads HEC-RAS example projects
 
 #### HDF Data Access Classes
@@ -280,7 +300,6 @@ This is useful for comparing different river systems, running scenario analyses
 - `HdfPipe`: Pipe network analysis tools
 - `HdfPump`: Pump station analysis capabilities
 - `HdfFluvialPluvial`: Fluvial-pluvial boundary analysis
-- `RasMapper`: RASMapper Functions
 - `HdfPlot` & `HdfResultsPlot`: Specialized plotting utilities
 
 ### Project Organization Diagram

{ras_commander-0.71.0.dist-info → ras_commander-0.73.0.dist-info}/RECORD

@@ -2,13 +2,13 @@ ras_commander/Decorators.py,sha256=EOYi20fyV6JgArpHO3lQEVAU6LPHbpa3wGlmIYS40K0,1
 ras_commander/HdfBase.py,sha256=Jws6Y8JFkharuiM6Br5ivp6MS64X2fL6y87FOpe3FQw,14219
 ras_commander/HdfBndry.py,sha256=FBNFoTz4sXVB-MOsbHJBP8P0dMqJUfBROloKTaxmzCo,16377
 ras_commander/HdfFluvialPluvial.py,sha256=dlqoFX5i7uSA2BvuRNrV-Fg-z2JaeUxY86_fbZAdGqI,25933
-ras_commander/HdfInfiltration.py,sha256=SB8EsB-w1zrUHXqn3G8ihEahViTIZF7c7AyPHIrSrOU,15473
+ras_commander/HdfInfiltration.py,sha256=HiifhbzgUs4kdtJkKfhxo1IsE-FBp5XspKkrJnnCDuc,66171
 ras_commander/HdfMesh.py,sha256=zI_4AqxDxb2_31G9RUmWibyld6KDMGhDpI3F8qwzVAw,19139
 ras_commander/HdfPipe.py,sha256=m-yvPL2GIP23NKt2tcwzOlS7khvgcDPGAshlTPMUAeI,32154
 ras_commander/HdfPlan.py,sha256=_KIWMoMpAftUp2wc2PQ9psl78IvW0disN0yKt7sNfqU,11807
 ras_commander/HdfPlot.py,sha256=7MNI5T9qIz-Ava1RdlnB6O9oJElE5BEB29QVF5Y2Xuc,3401
 ras_commander/HdfPump.py,sha256=Vc2ff16kRISR7jwtnaAqxI0p-gfBSuZKzR3rQbBLQoE,12951
-ras_commander/HdfResultsMesh.py,sha256=kjk5zXowgfscayiyKmSFdTDXa8-kPUI4SYKJ2okw3F0,31738
+ras_commander/HdfResultsMesh.py,sha256=MKnSJxcWVDccHaRRGgAK0szm7B-VtrKBtgL1Uz0kAiw,44662
 ras_commander/HdfResultsPlan.py,sha256=L3IOdF6R3XiA7mbFAyLdczrZJQJogd8hhl7UYJWT5fY,16246
 ras_commander/HdfResultsPlot.py,sha256=ylzfT78CfgoDO0XAlRwlgMNRzvNQYBMn9eyXyBfjv_w,7660
 ras_commander/HdfResultsXsec.py,sha256=-P7nXnbjOLAeUnrdSC_lJQSfzrlWKmDF9Z5gEjmxbJY,13031
@@ -18,14 +18,15 @@ ras_commander/HdfXsec.py,sha256=flREnFFrIZu4SSKGRQeX9w3SS49q0UWPJnq4zO7DbUM,2734
 ras_commander/LoggingConfig.py,sha256=gWe5K5XTmMQpSczsTysAqpC9my24i_IyM8dvD85fxYg,2704
 ras_commander/RasCmdr.py,sha256=37GnchoQ0fIAkPnssnCr1mRUXY8gm-hIMTmuHZlnYP8,34591
 ras_commander/RasExamples.py,sha256=6IZ96LcAsk5LYFehdD0zDW5wyZWxQa6OQu2N9upxWXA,17536
-ras_commander/RasGeo.py,sha256=Fi1APh3G6Q1FmX3H3Pc-oL_TD3Q6T8HeqN1jl31V39I,17427
+ras_commander/RasGeo.py,sha256=CQ1VjJ4uWWyXC9KsoVStbhlRf_5AiDm8yWvtDM3l4ac,21675
+ras_commander/RasMap.py,sha256=4cVzaaQure-CXdXB1BY29iE20S00eldUqoL96PvJPbw,10635
 ras_commander/RasPlan.py,sha256=7cgwsKjD40ZSj9uOnsHd-OfmBJFxkS2xFhWmlHQflak,62179
-ras_commander/RasPrj.py,sha256=IFy5CAQdZAQtqAnKQUFUqsDx8WQtYGXiRTG9IErBUE8,56457
+ras_commander/RasPrj.py,sha256=ivAHB3vexH6GQi-Aa4kqAabRwdthllMkTp8xphh5Ldc,57655
 ras_commander/RasUnsteady.py,sha256=TO08CT2GC4G5rcXO_Wbia2t4PhiWRu9-nC9F0IW7Gyo,37187
 ras_commander/RasUtils.py,sha256=0fm4IIs0LH1dgDj3pGd66mR82DhWLEkRKUvIo2M_5X0,35886
-ras_commander/__init__.py,sha256=KI_tROSOPwLR6JNKttQZHfvcTD0m-5zXAbd35c0Knrs,2001
-ras_commander-0.71.0.dist-info/licenses/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
-ras_commander-0.71.0.dist-info/METADATA,sha256=nhua8P2v_aWC8BmNnLMC6PqHNSBNoHSu5CP_QiRxrHs,26588
-ras_commander-0.71.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-ras_commander-0.71.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
-ras_commander-0.71.0.dist-info/RECORD,,
+ras_commander/__init__.py,sha256=Tl8kx5SQQ8UocWSQ1tFzg4FGNb702k2yikfD6_hwXIw,2039
+ras_commander-0.73.0.dist-info/licenses/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
+ras_commander-0.73.0.dist-info/METADATA,sha256=GiwhfJNCCL8ZH9XY1bpVa3huCeU84E1oOr7zIlrj4vs,27365
+ras_commander-0.73.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+ras_commander-0.73.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
+ras_commander-0.73.0.dist-info/RECORD,,