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

ras_commander/RasUnsteady.py

@@ -61,30 +61,29 @@ class RasUnsteady:
     @log_call
     def update_flow_title(unsteady_file: str, new_title: str, ras_object: Optional[Any] = None) -> None:
         """
-        Update the Flow Title in an unsteady flow file.
-        
+        Update the Flow Title in an unsteady flow file (.u*).
+
+        The Flow Title provides a descriptive identifier for unsteady flow scenarios in HEC-RAS. 
+        It appears in the HEC-RAS interface and helps differentiate between different flow files.
+
         Parameters:
-        unsteady_file (str): Full path to the unsteady flow file
-        new_title (str): New flow title (max 24 characters)
-        ras_object (RasPrj, optional): Specific RAS object to use. If None, uses the global ras instance.
-        
+            unsteady_file (str): Path to the unsteady flow file or unsteady flow number
+            new_title (str): New flow title (max 24 characters, will be truncated if longer)
+            ras_object (optional): Custom RAS object to use instead of the global one
+
         Returns:
-        None
+            None: The function modifies the file in-place and updates the ras object's unsteady dataframe
 
-        Note:
-            This function updates the ras object's unsteady dataframe after modifying the unsteady flow file.
-        
         Example:
-            from ras_commander import RasCmdr
+            # Clone an existing unsteady flow file
+            new_unsteady_number = RasPlan.clone_unsteady("02")
             
-            # Initialize RAS project
-            ras_cmdr = RasCmdr()
-            ras_cmdr.init_ras_project(project_folder, ras_version)
+            # Get path to the new unsteady flow file
+            new_unsteady_file = RasPlan.get_unsteady_path(new_unsteady_number)
             
-            # Update flow title
-            unsteady_file = r"path/to/unsteady_file.u01"
-            new_title = "New Flow Title"
-            RasUnsteady.update_flow_title(unsteady_file, new_title, ras_object=ras_cmdr.ras)
+            # Update the flow title
+            new_title = "Modified Flow Scenario"
+            RasUnsteady.update_flow_title(new_unsteady_file, new_title)
         """
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
@@ -134,30 +133,29 @@ class RasUnsteady:
     @log_call
     def update_restart_settings(unsteady_file: str, use_restart: bool, restart_filename: Optional[str] = None, ras_object: Optional[Any] = None) -> None:
         """
-        Update the Use Restart settings in an unsteady flow file.
-        
+        Update the restart file settings in an unsteady flow file.
+
+        Restart files in HEC-RAS allow simulations to continue from a previously saved state,
+        which is useful for long simulations or when making downstream changes.
+
         Parameters:
-        unsteady_file (str): Full path to the unsteady flow file
-        use_restart (bool): Whether to use restart (True) or not (False)
-        restart_filename (str, optional): Name of the restart file (required if use_restart is True)
-        ras_object (RasPrj, optional): Specific RAS object to use. If None, uses the global ras instance.
-        
+            unsteady_file (str): Path to the unsteady flow file
+            use_restart (bool): Whether to use a restart file (True) or not (False)
+            restart_filename (str, optional): Path to the restart file (.rst)
+                                             Required if use_restart is True
+            ras_object (optional): Custom RAS object to use instead of the global one
+
         Returns:
-        None
+            None: The function modifies the file in-place and updates the ras object's unsteady dataframe
 
-        Note:
-            This function updates the ras object's unsteady dataframe after modifying the unsteady flow file.
-        
         Example:
-            from ras_commander import RasCmdr
-            
-            # Initialize RAS project
-            ras_cmdr = RasCmdr()
-            ras_cmdr.init_ras_project(project_folder, ras_version)
-            
-            # Update restart settings
-            unsteady_file = r"path/to/unsteady_file.u01"
-            RasUnsteady.update_restart_settings(unsteady_file, True, "restartfile.rst", ras_object=ras_cmdr.ras)
+            # Enable restart file for an unsteady flow
+            unsteady_file = RasPlan.get_unsteady_path("03")
+            RasUnsteady.update_restart_settings(
+                unsteady_file, 
+                use_restart=True, 
+                restart_filename="model_restart.rst"
+            )
         """
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
@@ -219,8 +217,29 @@ class RasUnsteady:
     @log_call
     def extract_boundary_and_tables(unsteady_file: str, ras_object: Optional[Any] = None) -> pd.DataFrame:
         """
-        Extracts Boundary Location blocks, DSS File entries, and their associated 
-        fixed-width tables from the specified unsteady file.
+        Extract boundary conditions and their associated tables from an unsteady flow file.
+
+        Boundary conditions in HEC-RAS define time-varying inputs like flow hydrographs,
+        stage hydrographs, gate operations, and lateral inflows. This function parses these
+        conditions and their data tables from the unsteady flow file.
+
+        Parameters:
+            unsteady_file (str): Path to the unsteady flow file
+            ras_object (optional): Custom RAS object to use instead of the global one
+
+        Returns:
+            pd.DataFrame: DataFrame containing boundary conditions with the following columns:
+                - River Name, Reach Name, River Station: Location information
+                - DSS File: Associated DSS file path if any
+                - Tables: Dictionary containing DataFrames of time-series values
+
+        Example:
+            # Get the path to unsteady flow file "02"
+            unsteady_file = RasPlan.get_unsteady_path("02")
+            
+            # Extract boundary conditions and tables
+            boundaries_df = RasUnsteady.extract_boundary_and_tables(unsteady_file)
+            print(f"Extracted {len(boundaries_df)} boundary conditions from the file.")
         """
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
@@ -363,10 +382,25 @@ class RasUnsteady:
     @log_call
     def print_boundaries_and_tables(boundaries_df: pd.DataFrame) -> None:
         """
-        Prints the boundaries and their associated tables from the extracted DataFrame.
-        
+        Print boundary conditions and their associated tables in a formatted, readable way.
+
+        This function is useful for quickly visualizing the complex nested structure of 
+        boundary conditions extracted by extract_boundary_and_tables().
+
         Parameters:
-        - boundaries_df: DataFrame containing boundary information and nested tables data
+            boundaries_df (pd.DataFrame): DataFrame containing boundary information and 
+                                         nested tables data from extract_boundary_and_tables()
+
+        Returns:
+            None: Output is printed to console
+
+        Example:
+            # Extract boundary conditions and tables
+            boundaries_df = RasUnsteady.extract_boundary_and_tables(unsteady_file)
+            
+            # Print in a formatted way
+            print("Detailed boundary conditions and tables:")
+            RasUnsteady.print_boundaries_and_tables(boundaries_df)
         """
         pd.set_option('display.max_columns', None)
         pd.set_option('display.max_rows', None)
@@ -396,13 +430,28 @@ class RasUnsteady:
     @log_call
     def identify_tables(lines: List[str]) -> List[Tuple[str, int, int]]:
         """
-        Identify the start and end of each table in the unsteady flow file.
-        
+        Identify the start and end line numbers of tables in an unsteady flow file.
+
+        HEC-RAS unsteady flow files contain numeric tables in a fixed-width format.
+        This function locates these tables within the file and provides their positions.
+
         Parameters:
-        lines (List[str]): List of file lines
-        
+            lines (List[str]): List of file lines (typically from file.readlines())
+
         Returns:
-        List[Tuple[str, int, int]]: List of tuples containing (table_name, start_line, end_line)
+            List[Tuple[str, int, int]]: List of tuples where each tuple contains:
+                - table_name (str): The type of table (e.g., 'Flow Hydrograph=')
+                - start_line (int): Line number where the table data begins
+                - end_line (int): Line number where the table data ends
+
+        Example:
+            # Read the unsteady flow file
+            with open(new_unsteady_file, 'r') as f:
+                lines = f.readlines()
+                
+            # Identify tables in the file
+            tables = RasUnsteady.identify_tables(lines)
+            print(f"Identified {len(tables)} tables in the unsteady flow file.")
         """
         table_types = [
             'Flow Hydrograph=', 
@@ -437,15 +486,26 @@ class RasUnsteady:
     @log_call
     def parse_fixed_width_table(lines: List[str], start: int, end: int) -> pd.DataFrame:
         """
-        Parse a fixed-width table into a pandas DataFrame.
-        
+        Parse a fixed-width table from an unsteady flow file into a pandas DataFrame.
+
+        HEC-RAS uses a fixed-width format (8 characters per value) for numeric tables.
+        This function converts this format into a DataFrame for easier manipulation.
+
         Parameters:
-        lines (List[str]): List of file lines
-        start (int): Starting line number for table
-        end (int): Ending line number for table
-        
+            lines (List[str]): List of file lines (from file.readlines())
+            start (int): Starting line number for table data
+            end (int): Ending line number for table data
+
         Returns:
-        pd.DataFrame: DataFrame containing parsed table values
+            pd.DataFrame: DataFrame with a single column 'Value' containing the parsed numeric values
+
+        Example:
+            # Identify tables in the file
+            tables = RasUnsteady.identify_tables(lines)
+            
+            # Parse a specific table (e.g., first flow hydrograph)
+            table_name, start_line, end_line = tables[0]
+            table_df = RasUnsteady.parse_fixed_width_table(lines, start_line, end_line)
         """
         data = []
         for line in lines[start:end]:
@@ -489,14 +549,30 @@ class RasUnsteady:
     @log_call
     def extract_tables(unsteady_file: str, ras_object: Optional[Any] = None) -> Dict[str, pd.DataFrame]:
         """
-        Extract all tables from the unsteady flow file and return them as DataFrames.
-        
+        Extract all tables from an unsteady flow file and return them as DataFrames.
+
+        This function combines identify_tables() and parse_fixed_width_table() to extract
+        all tables from an unsteady flow file in a single operation.
+
         Parameters:
-        unsteady_file (str): Path to the unsteady flow file
-        ras_object (RasPrj, optional): Specific RAS object to use. If None, uses the global ras instance.
-        
+            unsteady_file (str): Path to the unsteady flow file
+            ras_object (optional): Custom RAS object to use instead of the global one
+
         Returns:
-        Dict[str, pd.DataFrame]: Dictionary of table names to DataFrames
+            Dict[str, pd.DataFrame]: Dictionary where:
+                - Keys are table names (e.g., 'Flow Hydrograph=')
+                - Values are DataFrames with a 'Value' column containing numeric data
+
+        Example:
+            # Extract all tables from the unsteady flow file
+            all_tables = RasUnsteady.extract_tables(new_unsteady_file)
+            print(f"Extracted {len(all_tables)} tables from the file.")
+            
+            # Access a specific table
+            flow_tables = [name for name in all_tables.keys() if 'Flow Hydrograph=' in name]
+            if flow_tables:
+                flow_df = all_tables[flow_tables[0]]
+                print(f"Flow table has {len(flow_df)} values")
         """
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
@@ -529,14 +605,32 @@ class RasUnsteady:
     def write_table_to_file(unsteady_file: str, table_name: str, df: pd.DataFrame, 
                            start_line: int, ras_object: Optional[Any] = None) -> None:
         """
-        Write updated table back to file in fixed-width format.
-        
+        Write an updated table back to an unsteady flow file in the required fixed-width format.
+
+        This function takes a modified DataFrame and writes it back to the unsteady flow file,
+        preserving the 8-character fixed-width format that HEC-RAS requires.
+
         Parameters:
-        unsteady_file (str): Path to the unsteady flow file
-        table_name (str): Name of the table to update
-        df (pd.DataFrame): DataFrame containing the updated values
-        start_line (int): Line number where the table starts
-        ras_object (RasPrj, optional): Specific RAS object to use. If None, uses the global ras instance.
+            unsteady_file (str): Path to the unsteady flow file
+            table_name (str): Name of the table to update (e.g., 'Flow Hydrograph=')
+            df (pd.DataFrame): DataFrame containing the updated values with a 'Value' column
+            start_line (int): Line number where the table data begins in the file
+            ras_object (optional): Custom RAS object to use instead of the global one
+
+        Returns:
+            None: The function modifies the file in-place
+
+        Example:
+            # Identify tables in the unsteady flow file
+            tables = RasUnsteady.identify_tables(lines)
+            table_name, start_line, end_line = tables[0]
+            
+            # Parse and modify the table
+            table_df = RasUnsteady.parse_fixed_width_table(lines, start_line, end_line)
+            table_df['Value'] = table_df['Value'] * 0.75  # Scale values to 75%
+            
+            # Write modified table back to the file
+            RasUnsteady.write_table_to_file(new_unsteady_file, table_name, table_df, start_line)
         """
         ras_obj = ras_object or ras
         ras_obj.check_initialized()

ras_commander/__init__.py

@@ -10,7 +10,7 @@ try:
     __version__ = version("ras-commander")
 except PackageNotFoundError:
     # package is not installed
-    __version__ = "0.68.0"
+    __version__ = "0.71.0"
 
 # Set up logging
 setup_logging()

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: ras-commander
-Version: 0.68.0
+Version: 0.71.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.
@@ -26,13 +26,18 @@ Dynamic: author-email
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
 # RAS Commander (ras-commander)
 
-RAS Commander is a Python library for automating HEC-RAS operations, providing a set of tools to interact with HEC-RAS project files, execute simulations, and manage project data. This library was initially conceptualized in the Australian Water School course "AI Tools for Modelling Innovation", and subsequently expanded to cover the basic functionality of the HECRASController COM32 interface using open-source python libraries.  This library uses a Test Driven Development strategy, leveraging the publicly-available HEC-RAS Example projects to create repeatable demonstration examples.  The "Commmander" moniker is inspired by the "Command Line is All You Need" approach to HEC-RAS automation that was first implemented in the HEC-Commander Tools repository. 
+<p align="center">
+  <img src="ras-commander_logo.svg" width=70%>
+</p>
+
+RAS Commander is a Python library for automating HEC-RAS operations, providing a set of tools to interact with HEC-RAS project files, execute simulations, and manage project data. This library was initially conceptualized in the Australian Water School course "AI Tools for Modelling Innovation", and subsequently expanded to cover much of the basic functionality of the HECRASController COM32 interface using open-source python libraries.  This library uses a Test Driven Development strategy, leveraging the publicly-available HEC-RAS Example projects to create repeatable demonstration examples.  The "Commmander" moniker is inspired by the "Command Line is All You Need" approach to HEC-RAS automation that was first implemented in the HEC-Commander Tools repository. 
 
 ## Repository Author:
 [William Katzenmeyer, P.E., C.F.M.](https://engineeringwithllms.info)
@@ -46,10 +51,15 @@ This repository has several methods of interaction with Large Language Models an
 
 2. **[Cursor IDE Integration](https://github.com/gpt-cmdr/ras-commander/blob/main/.cursorrules)**: Custom rules(.cursorrules) for the Cursor IDE to provide context-aware suggestions and documentation.  Just open the repository folder in Cursor to recognize these instructions.  You can create your own folders "/workspace/, "/projects/", or "my_projects/" as these are already in the .gitignore, and place your custom scripts there for your projects.  This will allow easy referencing of the ras-commander documents and individual repo files, the automatic loading of the .cursorrules file.  Alternatvely, download the github repo into your projects folder to easily load documents and use cursor rules files.
 
-3. **[RAS-Commander Library Assistant](https://github.com/gpt-cmdr/ras-commander/tree/main/ai_tools/library_assistant)**: 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**
+3. **[RAS-Commander Library Assistant](https://github.com/gpt-cmdr/ras-commander/blob/main/ai_tools/library_assistant/REAME.md)**:
+  
+
+<img align="left" width="25%" hspace="40" src="ai_tools/library_assistant/ras-commander_library_assistant.svg">
+
+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**
 
 
-4. **[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_
 
 
 ## Background

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

@@ -16,19 +16,16 @@ ras_commander/HdfStruc.py,sha256=SznjPvBWiqNVtviZvfCdjB_iwZF4UXxlIxITD8kwjP4,137
 ras_commander/HdfUtils.py,sha256=VkIKAXBrLwTlk2VtXSO-W3RU-NHpfHbE1QcZUZgl-t8,15248
 ras_commander/HdfXsec.py,sha256=flREnFFrIZu4SSKGRQeX9w3SS49q0UWPJnq4zO7DbUM,27342
 ras_commander/LoggingConfig.py,sha256=gWe5K5XTmMQpSczsTysAqpC9my24i_IyM8dvD85fxYg,2704
-ras_commander/RasCmdr.py,sha256=2i9gR5koFfBLwvhYAbNgQFNKKUKqxD1Hf6T9SN9sx-s,26558
+ras_commander/RasCmdr.py,sha256=37GnchoQ0fIAkPnssnCr1mRUXY8gm-hIMTmuHZlnYP8,34591
 ras_commander/RasExamples.py,sha256=6IZ96LcAsk5LYFehdD0zDW5wyZWxQa6OQu2N9upxWXA,17536
-ras_commander/RasGeo.py,sha256=M0sVNKlWmmbve8iMXLWq25WgbxqLWBo7_1oDg_rALzU,5607
-ras_commander/RasGpt.py,sha256=N_7p2nucWrBBXdB2k2ZKvOeOdXNmFD9dIY3W7_5i5nw,1206
-ras_commander/RasMapper.py,sha256=LO_blvQnd4pwkEU8A30-RoE-CYIoU3s_fNLHBoM8ljw,613
-ras_commander/RasPlan.py,sha256=0THxeB9ldeDuS4of2ruYG7Abbc5jz2729y5qOHntMuI,61664
-ras_commander/RasPrj.py,sha256=uJ8jHq_Y5-ZnQW6nWhTuHFfaDGuMrJo1HQRvd1QwINQ,50228
-ras_commander/RasToGo.py,sha256=TKujfaV1xQhFaOddF4g2ogGy6ky-CLlfelSMPD2J3Nk,1223
-ras_commander/RasUnsteady.py,sha256=KfCXAag-_bPwwS3JbPZH-s4hbaoHACO0mlRnGrzbFgA,32092
+ras_commander/RasGeo.py,sha256=Fi1APh3G6Q1FmX3H3Pc-oL_TD3Q6T8HeqN1jl31V39I,17427
+ras_commander/RasPlan.py,sha256=7cgwsKjD40ZSj9uOnsHd-OfmBJFxkS2xFhWmlHQflak,62179
+ras_commander/RasPrj.py,sha256=IFy5CAQdZAQtqAnKQUFUqsDx8WQtYGXiRTG9IErBUE8,56457
+ras_commander/RasUnsteady.py,sha256=TO08CT2GC4G5rcXO_Wbia2t4PhiWRu9-nC9F0IW7Gyo,37187
 ras_commander/RasUtils.py,sha256=0fm4IIs0LH1dgDj3pGd66mR82DhWLEkRKUvIo2M_5X0,35886
-ras_commander/__init__.py,sha256=dVjDtqWMWjV2x17oJEEZQWwyvpqxJJM9s9_zHe0SJXY,2001
-ras_commander-0.68.0.dist-info/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
-ras_commander-0.68.0.dist-info/METADATA,sha256=4VhVogHKCjgJb-nGJgsiQ9O3nI0jUBAAx5D_Xd8SJcw,26233
-ras_commander-0.68.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-ras_commander-0.68.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
-ras_commander-0.68.0.dist-info/RECORD,,
+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-0.68.0.dist-info → ras_commander-0.71.0.dist-info}/WHEEL

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

ras_commander/RasGpt.py

@@ -1,27 +0,0 @@
-import os
-from pathlib import Path
-from typing import Optional
-from ras_commander import get_logger, log_call
-
-logger = get_logger(__name__)
-
-class RasGpt:
-    """
-    A class containing helper functions for the RAS Commander GPT.
-    """
-    
-# to be implemented later
-# 
-# This class will contain  methods to help LLM's extract useful information from HEC-RAS models in a structured format with token budget etc. 
-# Templates will be used to help with this, based on the example projects (1D Steady, 1D Usteady, 1D Sediment Transport, 1D Water Quality, 2D Unsteady, 2D Steady, 2D Sediment Transport, 2D Water Quality, 2D Geospatial, 3D Unsteady, 3D Steady, 3D Sediment Transport, 3D Water Quality, 3D Geospatial).
-# These will simply filter the data to only include the relevant information for the area of focus. 
-
-#
-# IDEAS
-# 1. Package up a standard set of information for LLM analysis
-#       - General project information
-#       - Cross section information (for specific cross sections)
-#       - Structure information (for specific structures)
-#       - Include time series results and relevant HEC Guidance for LLM to reference
-
-# 2. Use Library Assistant to call LLM 

ras_commander/RasMapper.py

@@ -1,24 +0,0 @@
-"""
-Class: RasMapper
-
-List of Functions:
-    get_raster_map(hdf_path: Path) 
-    clip_raster_with_boundary(raster_path: Path, boundary_path: Path) 
-    calculate_zonal_stats(boundary_path: Path, raster_data, transform, nodata) 
-
-"""
-
-
-
-from pathlib import Path
-import pandas as pd
-import geopandas as gpd
-import rasterio
-from rasterio.mask import mask
-import h5py
-from .Decorators import log_call, standardize_input
-from .HdfInfiltration import HdfInfiltration
-
-class RasMapper:
-    """Class for handling RAS Mapper operations and data extraction"""
-    # PLACEHOLDER FOR FUTURE DEVELOPMENT

ras_commander/RasToGo.py

@@ -1,37 +0,0 @@
-"""
-RasToGo module provides functions to interface HEC-RAS with go-consequences.
-This module helps prepare and format RAS data for use with go-consequences.
-
-
------
-
-All of the methods in this class are static and are designed to be used without instantiation.
-
-List of Functions in RasToGo:
-
-TO BE IMPLEMENTED: 
-- Adding stored maps in rasmaapper for a results file
-- Editing the terrain name for stored maps, so that a reduced resolution terrain can be used for mapping
-- Re-computing specific plans using the floodplain mapping option to generate stored maps
-- Using the stored map output to call go-consequences and compute damages
-- Comparisons of go-consequences outputs based on RAS plan number
-    - include optional argument with polygons defining areas of interest
-
-"""
-
-import logging
-from pathlib import Path
-from typing import Dict, List, Optional, Any, Tuple, Union
-import pandas as pd
-import numpy as np
-
-from .Decorators import log_call, standardize_input
-from .LoggingConfig import setup_logging, get_logger
-
-logger = get_logger(__name__)
-
-class RasToGo:
-    """Class containing functions to interface HEC-RAS with go-consequences."""
-
-    #@staticmethod
-    #@log_call