ras-commander 0.21.0__py2.py3-none-any.whl → 0.22.0.dev0__py2.py3-none-any.whl

ras_commander/RasCommander.py

@@ -327,18 +327,27 @@ class RasCommander:
         if dest_folder is not None:
             dest_folder_path = Path(dest_folder)
             if dest_folder_path.exists():
-                raise ValueError(
-                    f"\nError: Destination folder already exists: '{dest_folder_path}'\n"
-                    f"To prevent accidental overwriting of results, this operation cannot proceed.\n"
-                    f"Please take one of the following actions:\n"
-                    f"1. Delete the folder manually and run the operation again.\n"
-                    f"2. Use a different destination folder name.\n"
-                    f"3. Programmatically delete the folder before calling compute_parallel, like this:\n"
-                    f"   if Path('{dest_folder_path}').exists():\n"
-                    f"       shutil.rmtree('{dest_folder_path}')\n"
-                    f"This safety measure ensures that you don't inadvertently overwrite existing results."
-                )
-            shutil.copytree(project_folder, dest_folder_path)
+                if any(dest_folder_path.iterdir()):
+                    raise ValueError(
+                        f"\nError: Destination folder already exists: '{dest_folder_path}'\n"
+                        f"To prevent accidental overwriting of results, this operation cannot proceed.\n"
+                        f"Please take one of the following actions:\n"
+                        f"1. Delete the folder manually and run the operation again.\n"
+                        f"2. Use a different destination folder name.\n"
+                        f"3. Programmatically delete the folder before calling compute_parallel, like this:\n"
+                        f"   if Path('{dest_folder_path}').exists():\n"
+                        f"       shutil.rmtree('{dest_folder_path}')\n"
+                        f"This safety measure ensures that you don't inadvertently overwrite existing results."
+                    )
+            else:
+                try:
+                    dest_folder_path.mkdir(parents=True, exist_ok=True)
+                except PermissionError:
+                    raise PermissionError(f"Unable to create destination folder '{dest_folder_path}'. Permission denied.")
+            try:
+                shutil.copytree(project_folder, dest_folder_path, dirs_exist_ok=True)
+            except shutil.Error as e:
+                raise IOError(f"Error copying project to destination folder: {str(e)}")
             project_folder = dest_folder_path  # Update project_folder to the new destination
 
         if plan_numbers:

ras_commander/RasGeo.py

@@ -61,9 +61,14 @@ class RasGeo:
             geom_preprocessor_suffix = '.c' + ''.join(plan_path.suffixes[1:]) if plan_path.suffixes else '.c'
             geom_preprocessor_file = plan_path.with_suffix(geom_preprocessor_suffix)
             if geom_preprocessor_file.exists():
-                print(f"Deleting geometry preprocessor file: {geom_preprocessor_file}")
-                geom_preprocessor_file.unlink()
-                print("File deletion completed successfully.")
+                try:
+                    print(f"Deleting geometry preprocessor file: {geom_preprocessor_file}")
+                    geom_preprocessor_file.unlink()
+                    print("File deletion completed successfully.")
+                except PermissionError:
+                    raise PermissionError(f"Unable to delete geometry preprocessor file: {geom_preprocessor_file}. Permission denied.")
+                except OSError as e:
+                    raise OSError(f"Error deleting geometry preprocessor file: {geom_preprocessor_file}. {str(e)}")
             else:
                 print(f"No geometry preprocessor file found for: {plan_file}")
         

ras_commander/RasPlan.py

@@ -16,11 +16,12 @@ class RasPlan:
     """
     
     @staticmethod
-    def set_geom(self, new_geom: Union[str, int], ras_object=None) -> pd.DataFrame:
+    def set_geom(plan_number: Union[str, int], new_geom: Union[str, int], ras_object=None) -> pd.DataFrame:
         """
-        Set the geometry for the current plan.
+        Set the geometry for the specified plan.
 
         Parameters:
+            plan_number (Union[str, int]): The plan number to update.
             new_geom (Union[str, int]): The new geometry number to set.
             ras_object: An optional RAS object instance.
 
@@ -28,8 +29,7 @@ class RasPlan:
             pd.DataFrame: The updated geometry DataFrame.
 
         Example:
-            plan = RasPlan('path/to/plan.p01')
-            updated_geom_df = plan.set_geom('G01')
+            updated_geom_df = RasPlan.set_geom('02', '03')
 
         Note:
             This function updates the ras object's dataframes after modifying the project structure.
@@ -37,25 +37,56 @@ class RasPlan:
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
 
-        geom_df = ras_obj.geom_df
-
-        if new_geom not in geom_df['geom_number']:
-            raise ValueError(f"Geometry {new_geom} not found in project.")
-
-        self.geom = new_geom
-        geom_df.loc[geom_df['plan_number'] == self.plan_number, 'geom_number'] = new_geom
-
-        print(f"Geometry for plan {self.plan_number} set to {new_geom}")
-        print("Updated geometry DataFrame:")
-        display(geom_df)
+        # Ensure plan_number and new_geom are strings
+        plan_number = str(plan_number).zfill(2)
+        new_geom = str(new_geom).zfill(2)
 
+        # Before doing anything, make sure the plan, geom, flow, and unsteady dataframes are current
         ras_obj.plan_df = ras_obj.get_plan_entries()
         ras_obj.geom_df = ras_obj.get_geom_entries()
         ras_obj.flow_df = ras_obj.get_flow_entries()
         ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
+        
+        # List the geom_df for debugging
+        print("Current geometry DataFrame within the function:")
+        print(ras_obj.geom_df)
+        
+        if new_geom not in ras_obj.geom_df['geom_number'].values:
+            raise ValueError(f"Geometry {new_geom} not found in project.")
+
+        # Update the geometry for the specified plan
+        ras_obj.plan_df.loc[ras_obj.plan_df['plan_number'] == plan_number, 'geom_number'] = new_geom
 
-        return geom_df
+        print(f"Geometry for plan {plan_number} set to {new_geom}")
+        print("Updated plan DataFrame:")
+        display(ras_obj.plan_df)
+
+        # Update the project file
+        prj_file_path = ras_obj.prj_file
+        with open(prj_file_path, 'r') as f:
+            lines = f.readlines()
+
+        plan_pattern = re.compile(rf"^Plan File=p{plan_number}", re.IGNORECASE)
+        geom_pattern = re.compile(r"^Geom File=g\d+", re.IGNORECASE)
         
+        for i, line in enumerate(lines):
+            if plan_pattern.match(line):
+                for j in range(i+1, len(lines)):
+                    if geom_pattern.match(lines[j]):
+                        lines[j] = f"Geom File=g{new_geom}\n"
+                        break
+                break
+
+        with open(prj_file_path, 'w') as f:
+            f.writelines(lines)
+
+        print(f"Updated project file with new geometry for plan {plan_number}")
+
+        # Re-initialize the ras object to reflect changes
+        ras_obj.initialize(ras_obj.project_folder, ras_obj.ras_exe_path)
+
+        return ras_obj.plan_df
+
     @staticmethod
     def set_steady(plan_number: str, new_steady_flow_number: str, ras_object=None):
         """
@@ -148,7 +179,11 @@ class RasPlan:
         if not plan_file_path:
             raise FileNotFoundError(f"Plan file not found: {plan_number}")
         
-        RasPlan.update_plan_file(plan_file_path, 'Unsteady', new_unsteady_flow_number)
+        
+        # DEV NOTE: THIS WORKS HERE, BUT IN OTHER FUNCTIONS WE DO THIS MANUALLY.  
+        # UPDATE OTHER FUNCTIONS TO USE RasUtils.update_plan_file INSTEAD OF REPLICATING THIS CODE.
+        
+        RasUtils.update_plan_file(plan_file_path, 'Unsteady', new_unsteady_flow_number)
         print(f"Updated unsteady flow file in {plan_file_path} to u{new_unsteady_flow_number}")
 
         ras_obj.plan_df = ras_obj.get_plan_entries()
@@ -316,6 +351,16 @@ class RasPlan:
         # Update the plan dataframe in the ras instance to ensure it is current
         ras_obj.plan_df = ras_obj.get_plan_entries()
         
+        # Ensure plan_number is a string
+        plan_number = str(plan_number)
+        
+        # Ensure plan_number is formatted as '01', '02', etc.
+        plan_number = plan_number.zfill(2)
+        
+        # print the ras_obj.plan_df dataframe
+        print("Plan DataFrame:")
+        display(ras_obj.plan_df)
+        
         plan_entry = ras_obj.plan_df[ras_obj.plan_df['plan_number'] == plan_number]
         if not plan_entry.empty:
             results_path = plan_entry['HDF_Results_Path'].iloc[0]
@@ -1096,7 +1141,6 @@ class RasPlan:
         
         return new_steady
 
-
     @staticmethod
     def clone_geom(template_geom, ras_object=None):
         """
@@ -1109,13 +1153,15 @@ class RasPlan:
         
         Returns:
         str: New geometry number (e.g., '03')
+
+        Note:
+            This function updates the ras object's dataframes after modifying the project structure.
         """
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
 
         # Update geometry entries without reinitializing the entire project
-        ras_obj.geom_df = ras_obj.get_prj_entries('Geom')  # Call the correct function to get updated geometry entries
-        #print(f"Updated geometry entries:\n{ras_obj.geom_df}")
+        ras_obj.geom_df = ras_obj.get_prj_entries('Geom')
 
         template_geom_filename = f"{ras_obj.project_name}.g{template_geom}"
         template_geom_path = ras_obj.project_folder / template_geom_filename
@@ -1178,13 +1224,17 @@ class RasPlan:
         print(f"Updated {ras_obj.prj_file} with new geometry file g{next_geom_number}")
         new_geom = next_geom_number
         
-        # Update the geometry entries in the ras object
+        # Update all dataframes in the ras object
+        ras_obj.plan_df = ras_obj.get_plan_entries()
         ras_obj.geom_df = ras_obj.get_geom_entries()
+        ras_obj.flow_df = ras_obj.get_flow_entries()
+        ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
+
         print(f"Updated geometry entries:\n{ras_obj.geom_df}")
 
         return new_geom
-        
-        
+            
+            
         
         
     @staticmethod

ras_commander/RasUnsteady.py

@@ -33,8 +33,14 @@ class RasUnsteady:
         ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
         
         unsteady_path = Path(unsteady_file)
-        with open(unsteady_path, 'r') as f:
-            lines = f.readlines()
+        try:
+            with open(unsteady_path, 'r') as f:
+                lines = f.readlines()
+        except FileNotFoundError:
+            raise FileNotFoundError(f"Unsteady flow file not found: {unsteady_path}")
+        except PermissionError:
+            raise PermissionError(f"Permission denied when reading unsteady flow file: {unsteady_path}")
+        
         updated = False
         for i, line in enumerate(lines):
             for param, new_value in modifications.items():
@@ -43,8 +49,13 @@ class RasUnsteady:
                     updated = True
                     print(f"Updated {param} to {new_value}")
         if updated:
-            with open(unsteady_path, 'w') as f:
-                f.writelines(lines)
+            try:
+                with open(unsteady_path, 'w') as f:
+                    f.writelines(lines)
+            except PermissionError:
+                raise PermissionError(f"Permission denied when writing to unsteady flow file: {unsteady_path}")
+            except IOError as e:
+                raise IOError(f"Error writing to unsteady flow file: {unsteady_path}. {str(e)}")
             print(f"Applied modifications to {unsteady_file}")
         else:
             print(f"No matching parameters found in {unsteady_file}")

ras_commander/RasUtils.py

@@ -1,11 +1,13 @@
 """
 Utility functions for the ras_commander library.
 """
+import os
 import shutil
 import logging
 import time
 from pathlib import Path
 from .RasPrj import ras
+from typing import Union
 
 class RasUtils:
     """
@@ -167,25 +169,35 @@ class RasUtils:
             return None
 
     @staticmethod
-    def get_plan_path(current_plan_number: int, ras_object=None) -> Path:
+    def get_plan_path(current_plan_number_or_path: Union[str, Path], ras_object=None) -> Path:
         """
-        Get the path for a plan file with a given plan number.
+        Get the path for a plan file with a given plan number or path.
 
         Parameters:
-        current_plan_number (int): The plan number (1 to 99)
+        current_plan_number_or_path (Union[str, Path]): The plan number (1 to 99) or full path to the plan file
         ras_object (RasPrj, optional): RAS object to use. If None, uses the default ras object.
 
         Returns:
-        Path: Full path to the plan file with the given plan number
+        Path: Full path to the plan file
 
         Example:
         >>> plan_path = RasUtils.get_plan_path(1)
         >>> print(f"Plan file path: {plan_path}")
+        >>> plan_path = RasUtils.get_plan_path("path/to/plan.p01")
+        >>> print(f"Plan file path: {plan_path}")
         """
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
         
-        current_plan_number = f"{int(current_plan_number):02d}"  # Ensure two-digit format
+        plan_path = Path(current_plan_number_or_path)
+        if plan_path.is_file():
+            return plan_path
+        
+        try:
+            current_plan_number = f"{int(current_plan_number_or_path):02d}"  # Ensure two-digit format
+        except ValueError:
+            raise ValueError(f"Invalid plan number: {current_plan_number_or_path}. Expected a number from 1 to 99.")
+        
         plan_name = f"{ras_obj.project_name}.p{current_plan_number}"
         return ras_obj.project_folder / plan_name
 
@@ -231,12 +243,12 @@ class RasUtils:
         return False
 
     @staticmethod
-    def update_plan_file(plan_number: int, file_type: str, entry_number: int, ras_object=None) -> None:
+    def update_plan_file(plan_number_or_path: Union[str, Path], file_type: str, entry_number: int, ras_object=None) -> None:
         """
         Update a plan file with a new file reference.
 
         Parameters:
-        plan_number (int): The plan number (1 to 99)
+        plan_number_or_path (Union[str, Path]): The plan number (1 to 99) or full path to the plan file
         file_type (str): Type of file to update ('Geom', 'Flow', or 'Unsteady')
         entry_number (int): Number (from 1 to 99) to set
         ras_object (RasPrj, optional): RAS object to use. If None, uses the default ras object.
@@ -247,6 +259,7 @@ class RasUtils:
 
         Example:
         >>> update_plan_entries(1, "Geom", 2)
+        >>> update_plan_entries("path/to/plan.p01", "Geom", 2)
         """
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
@@ -255,7 +268,10 @@ class RasUtils:
         if file_type not in valid_file_types:
             raise ValueError(f"Invalid file_type. Expected one of: {', '.join(valid_file_types.keys())}")
 
-        plan_file_path = RasUtils.get_plan_path(plan_number, ras_object)
+        plan_file_path = Path(plan_number_or_path)
+        if not plan_file_path.is_file():
+            plan_file_path = RasUtils.get_plan_path(plan_number_or_path, ras_object)
+        
         if not plan_file_path.exists():
             raise FileNotFoundError(f"Plan file not found: {plan_file_path}")
 
@@ -263,7 +279,8 @@ class RasUtils:
         search_pattern = f"{file_type} File="
         entry_number = f"{int(entry_number):02d}"  # Ensure two-digit format
 
-        with plan_file_path.open('r') as file:
+        RasUtils.check_file_access(plan_file_path, 'r')
+        with open(plan_file_path, 'r') as file:
             lines = file.readlines()
 
         for i, line in enumerate(lines):
@@ -281,3 +298,13 @@ class RasUtils:
         ras_obj.flow_df = ras_obj.get_flow_entries()
         ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
 
+    @staticmethod
+    def check_file_access(file_path, mode='r'):
+        path = Path(file_path)
+        if not path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+        if mode in ('r', 'rb') and not os.access(path, os.R_OK):
+            raise PermissionError(f"Read permission denied for file: {file_path}")
+        if mode in ('w', 'wb', 'a', 'ab') and not os.access(path.parent, os.W_OK):
+            raise PermissionError(f"Write permission denied for directory: {path.parent}")
+

ras_commander/_version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.22.0.dev0'
+__version_tuple__ = version_tuple = (0, 22, 0, 'dev0')

{ras_commander-0.21.0.dist-info → ras_commander-0.22.0.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ras_commander
-Version: 0.21.0
+Version: 0.22.0.dev0
 Summary: A library for automating HEC-RAS operations using python functions.
 Author-email: "William Katzenmeyer, P.E., C.F.M." <heccommander@gmail.com>
 Project-URL: Homepage, https://github.com/yourusername/ras_commander
@@ -11,164 +11,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
-## RAS-Commander Library Organization
-
-| Directory/File | Purpose |
-|---|---|
-| ras_commander/__init__.py | Initializes the library and defines the public API. |
-| ras_commander/RasCommander.py | Handles execution of HEC-RAS simulations. |
-| ras_commander/RasFileOps.py | Provides functions for reading and parsing HEC-RAS project files. |
-| ras_commander/RasGeo.py | Provides functions for manipulating geometry files. |
-| ras_commander/RasPlan.py | Provides functions for modifying and updating plan files. |
-| ras_commander/RasPrj.py | Defines the RasPrj class for managing project-level information. |
-| ras_commander/rasinit.py | Provides the `init_ras_project` function to initialize a project. |
-| ras_commander/RasPrj.py | Provides functions for managing HEC-RAS projects (e.g., copying files, updating project file). |
-| ras_commander/RasUnsteady.py | Provides functions for manipulating unsteady flow files. |
-| ras_commander/RasUtils.py | Provides general utility functions (e.g., file backup, directory creation). |
-
-## Project Organization Diagram
-
-```
-ras_commander
-├── .github
-│   └── workflows
-│       └── python-package.yml
-├── ras_commander
-│   ├── __init__.py
-│   ├── RasCommander.py
-│   ├── RasFileOps.py
-│   ├── RasGeo.py
-│   ├── RasPlan.py
-│   ├── RasPrj.py
-│   ├── rasinit.py
-│   ├── RasPrj.py
-│   ├── RasUnsteady.py
-│   └── RasUtils.py
-├── tests
-│   └── ... (test files)
-├── .gitignore
-├── LICENSE
-├── README.md
-├── pyproject.toml
-├── setup.cfg
-└── setup.py
-```
-
-## Functions Overview
-
-| Function | Arguments | Purpose |
-|---|---|---|
-| `init_ras_project` | `ras_project_folder`, `ras_exe_path` | Initializes a HEC-RAS project by setting up the `RasPrj` with project details. |
-| `compute_plan` | `plan_file` | Executes a HEC-RAS plan file. |
-| `compute_plan_from_folder` | `test_plan_file`, `test_folder_path` | Execute a single HEC-RAS plan from a folder other than the project path. |
-| `compute_test_mode` | `project_folder` | Recreates the -test function from the HEC-RAS interface, primarily by copying the project directory, forcing recomputation, and running each plan. |
-| `compute_parallel` | `config`, `max_workers`, `cores_per_run` | Run HEC-RAS plans in parallel. |
-| `compute_parallel_all` | `project_folder`, `ras_exe_path` | Run all HEC-RAS plans in parallel from a project folder path. | 
-
-[The rest of the function list remains the same, just ensure the class names are updated to their new lowercase versions]
-
-## Potential Uses of RAS-Commander Functions
-
-[This section remains unchanged]
-
-## GitHub Actions
-
-[This section remains unchanged]
-
-## Basic Usage Instructions
-
-To get started with RAS-Commander, follow these steps:
-
-1. Install the library:
-   ```
-   pip install ras-commander
-   ```
-
-2. Import the necessary modules:
-   ```python
-   from ras_commander import rasinit, RasFileOps, RasPrj, RasPlan, RasGeo, RasUnsteady, RasCommander, RasUtils
-   ```
-
-3. Initialize a HEC-RAS project:
-   ```python
-   project_folder = r"C:\path\to\your\project"
-   ras_exe_path = r"C:\Program Files (x86)\HEC\HEC-RAS\6.5\Ras.exe"
-   config = rasinit(project_folder, ras_exe_path)
-   ```
-
-4. Perform operations on your HEC-RAS project. For example:
-
-   - Execute a single plan:
-     ```python
-     plan_file = RasPlan.get_plan_path("01")
-     RasCommander.compute_plan(plan_file)
-     ```
-
-   - Run multiple plans in parallel:
-     ```python
-     max_workers = 2
-     cores_per_run = 1
-     results = RasCommander.compute_parallel(config, max_workers, cores_per_run)
-     ```
-
-   - Copy and modify geometry files:
-     ```python
-     RasGeo.clone_geom(config.project_folder, "01")
-     plan_file = RasPlan.get_plan_path("01")
-     RasGeo.set_geom(plan_file, "02")
-     ```
-
-   - Work with unsteady flow files:
-     ```python
-     new_unsteady_number = RasUnsteady.clone_unsteady(config.project_folder, "01")
-     plan_file = RasPlan.get_plan_path("01")
-     RasUnsteady.set_unsteady(plan_file, new_unsteady_number)
-     ```
-
-5. Access project information:
-   ```python
-   print(f"Project name: {config.project_name}")
-   print(f"Project file: {config.prj_file}")
-   print(f"Project folder: {config.project_folder}")
-   ```
-
-For more detailed examples and advanced usage, refer to the function documentation and the examples provided in the repository.
-
-
-
-
-NOTES: INCORPORATE INTO THE README.MD FILE ABOVE UNDER A NEW SECTION FOR CURRENT USES AND ROADMAP ITEMS, THEN DELETE THIS NOTE
-
-
-Potential Uses of HEC-RAS Automation Functions
-This set of functions provides a powerful foundation for automating various aspects of HEC-RAS modeling workflows. Here are some potential applications:
-1. Calibration and Sensitivity Analysis:
-Automated Parameter Variation: Users can create multiple simulation scenarios with varying parameters (e.g., Manning's n values, boundary conditions, initial conditions) to calibrate their model against observed data.
-Sensitivity Testing: Evaluate the impact of different input parameters on model outputs by generating a range of scenarios and analyzing the results. This helps identify critical parameters that require more attention during calibration.
-2. Real-time Forecasting:
-Dynamic Model Updates: Integrate with external data sources (e.g., weather forecasts, streamflow observations) to automatically update boundary conditions and initial conditions in unsteady flow files before running the simulation.
-Ensemble Forecasting: Generate multiple forecasts by incorporating uncertainty in input data and model parameters. This provides a more comprehensive understanding of potential future flow conditions.
-3. Scenario Analysis:
-Land Use Change Impacts: Evaluate the effects of land use changes on flood risk by modifying Manning's n values using extract_2d_mannings_tables, modify_2d_mannings_table, and write_2d_mannings_tables and running simulations with updated geometry files.
-Climate Change Impacts: Analyze the potential impacts of projected climate changes on flood risk by adjusting precipitation patterns and other relevant parameters in unsteady flow files.
-4. Batch Processing and High-Performance Computing:
-Large-scale Model Runs: Utilize run_plans_parallel to execute multiple simulations concurrently on a multi-core system, significantly reducing processing time for large-scale models or complex scenarios.
-Automated Report Generation: Integrate with Python libraries like matplotlib and bokeh to automatically generate customized reports summarizing simulation results, including tables, figures, and maps.
-5. Model Development and Testing:
-Rapid Prototyping: Quickly set up and run new model configurations using template files and automated workflows, facilitating rapid model development and testing.
-Regression Testing: Ensure model integrity and consistency after code changes or updates by automatically running a predefined set of simulations and comparing results with expected outputs.
-6. User-Friendly Interfaces:
-GUI Development: Integrate with Python GUI libraries like Tkinter or PyQt to create user-friendly interfaces for automating HEC-RAS workflows, allowing non-programmers to access the power of automation.
-
-
-
-
-
-
-Certainly! I'll create an updated README.md for the ras_commander library, incorporating the information you've provided and the context from the previous HEC-Commander tools. Here's the updated README.md:
-
-```markdown
-# ras_commander
+# 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 is an evolution of the RAS-Commander 1.0 Python Notebook Application previously released under the HEC-Commander tools.
 
@@ -186,13 +29,13 @@ ras_commander is a Python library for automating HEC-RAS operations, providing a
 Install ras_commander using pip:
 
 ```bash
-pip install ras_commander
+pip install ras-commander
 ```
 
 ## Requirements
 
 - Python 3.9+
-- HEC-RAS 6.5 (other versions may work but are not officially supported)
+- HEC-RAS 6.2 or later (other versions may work, all testing was done with version 6.2 and above)
 
 For a full list of dependencies, see the `requirements.txt` file.
 
@@ -297,9 +140,10 @@ ras_commander
 ├── setup.cfg
 ├── setup.py
 └── requirements.txt
+```
 
 
-## Inclusion of .cursorrules for AI-driven Coding Experience
+## Inclusion of .cursorrules and ai_tools for AI-driven Coding Experience
 
 Open the ras_commander folder in the Cursor IDE, and it will automatically include the .cursorrules file in your instructions.  Additionally, two other provided methods for interacting with the library though your current AI subscriptions: 
 
@@ -308,6 +152,7 @@ Open the ras_commander folder in the Cursor IDE, and it will automatically inclu
    - Entire code base: LINK HERE (TOKEN COUNT) (for Claude or Gemini)
    - Examples and Function Docstrings Only: LINK HERE (TOKEN COUNT) (for GPT-4o, o1 or Llama 3.1 405b)
 - Cursor IDE through .cursorrules file
+- 'rascommander_code_assistant.ipynb' notebook in the ras_commander folder, which allows for dynamic summarization of the code base and API chatting directly through the notebook. 
 
 There are a series of scripts provided in the "llm_summaries" folder that provide summaries of the code base, and the docstrings of the functions.  They can be run in your local environment, or provided to ChatGPT's code interpreter for execution.  
 
@@ -324,8 +169,6 @@ We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) f
 This project follows a specific style guide to maintain consistency across the codebase. Please refer to the [Style Guide](STYLE_GUIDE.md) for details on coding conventions, documentation standards, and best practices.
 
 
-
-
 ## License
 
 ras_commander is released under the MIT License. See the license file for details.
@@ -340,3 +183,36 @@ ras_commander is based on the HEC-Commander project's "Command Line is All You N
 
 For questions, suggestions, or support, please contact:
 William Katzenmeyer, P.E., C.F.M. - billk@fenstermaker.com
+
+
+
+
+
+
+
+
+
+NOTES: INCORPORATE INTO THE README.MD FILE ABOVE UNDER A NEW SECTION FOR CURRENT USES AND ROADMAP ITEMS, THEN DELETE THIS NOTE
+
+
+Potential Uses of HEC-RAS Automation Functions
+This set of functions provides a powerful foundation for automating various aspects of HEC-RAS modeling workflows. Here are some potential applications:
+1. Calibration and Sensitivity Analysis:
+Automated Parameter Variation: Users can create multiple simulation scenarios with varying parameters (e.g., Manning's n values, boundary conditions, initial conditions) to calibrate their model against observed data.
+Sensitivity Testing: Evaluate the impact of different input parameters on model outputs by generating a range of scenarios and analyzing the results. This helps identify critical parameters that require more attention during calibration.
+2. Real-time Forecasting:
+Dynamic Model Updates: Integrate with external data sources (e.g., weather forecasts, streamflow observations) to automatically update boundary conditions and initial conditions in unsteady flow files before running the simulation.
+Ensemble Forecasting: Generate multiple forecasts by incorporating uncertainty in input data and model parameters. This provides a more comprehensive understanding of potential future flow conditions.
+3. Scenario Analysis:
+Land Use Change Impacts: Evaluate the effects of land use changes on flood risk by modifying Manning's n values using extract_2d_mannings_tables, modify_2d_mannings_table, and write_2d_mannings_tables and running simulations with updated geometry files.
+Climate Change Impacts: Analyze the potential impacts of projected climate changes on flood risk by adjusting precipitation patterns and other relevant parameters in unsteady flow files.
+4. Batch Processing and High-Performance Computing:
+Large-scale Model Runs: Utilize run_plans_parallel to execute multiple simulations concurrently on a multi-core system, significantly reducing processing time for large-scale models or complex scenarios.
+Automated Report Generation: Integrate with Python libraries like matplotlib and bokeh to automatically generate customized reports summarizing simulation results, including tables, figures, and maps.
+5. Model Development and Testing:
+Rapid Prototyping: Quickly set up and run new model configurations using template files and automated workflows, facilitating rapid model development and testing.
+Regression Testing: Ensure model integrity and consistency after code changes or updates by automatically running a predefined set of simulations and comparing results with expected outputs.
+6. User-Friendly Interfaces:
+GUI Development: Integrate with Python GUI libraries like Tkinter or PyQt to create user-friendly interfaces for automating HEC-RAS workflows, allowing non-programmers to access the power of automation.
+
+

ras_commander-0.22.0.dev0.dist-info/RECORD

@@ -0,0 +1,15 @@
+ras_commander/README.md,sha256=MNWyvD9-MA3m3_HRZCk4uzrtIjyyYhhFs5CZ9M8ZNEo,5936
+ras_commander/RasCommander.py,sha256=tpi_RqFLxrV08eFhcVoaf1e_j9539lMpyPKIT0EjHT0,21814
+ras_commander/RasExamples.py,sha256=qNV1KK42S0TllyQ3wWnahQT2GEW1R-_39XI-fOYQemQ,13548
+ras_commander/RasGeo.py,sha256=0yNqnjEWh4KcItI9hUPczJ3AhPjld4rFY-W-gNUrnUI,3933
+ras_commander/RasPlan.py,sha256=FU2o9nagq6UXv04WRY6gG01Ef0wOEsJJdqVqMjZ45O0,51789
+ras_commander/RasPrj.py,sha256=LhlMR6qP9xvLMiPFuwRhRM5yosyLH2h1EyZbnhKgxE8,15163
+ras_commander/RasUnsteady.py,sha256=rsJH45WQU_30lytEgKY2Uxb4LYyHjgJ82UhA2rWzHOM,2442
+ras_commander/RasUtils.py,sha256=aSPkqhbfxomEhNZVL9MAZ_Lf0IF3y5L89tcC5WJAkXs,11732
+ras_commander/__init__.py,sha256=eoOVbWnLH-e405O6ADkO6qhx45a0n60CFgFl7mj4HYs,1089
+ras_commander/_version.py,sha256=Ss5vVtwnG84xro0FVNRmQeuiMm2EPPdx1J-Vny18ryM,426
+ras_commander-0.22.0.dev0.dist-info/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
+ras_commander-0.22.0.dev0.dist-info/METADATA,sha256=8nFhNB_dSh_OY_tt2pkqNMiPQJELc4mifgoMJks4ao4,10057
+ras_commander-0.22.0.dev0.dist-info/WHEEL,sha256=AHX6tWk3qWuce7vKLrj7lnulVHEdWoltgauo8bgCXgU,109
+ras_commander-0.22.0.dev0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
+ras_commander-0.22.0.dev0.dist-info/RECORD,,

{ras_commander-0.21.0.dist-info → ras_commander-0.22.0.dev0.dist-info}/WHEEL

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

ras_commander-0.21.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-ras_commander/README.md,sha256=MNWyvD9-MA3m3_HRZCk4uzrtIjyyYhhFs5CZ9M8ZNEo,5936
-ras_commander/RasCommander.py,sha256=tsCsvHdjbB28_tqJhy4h5iyYfgd5aLCcI0IfsN_GUqM,21277
-ras_commander/RasExamples.py,sha256=qNV1KK42S0TllyQ3wWnahQT2GEW1R-_39XI-fOYQemQ,13548
-ras_commander/RasGeo.py,sha256=VY7-Ksw2iclH9C9mY7unQ_a11aCkCLiyhmFgJmSNdsk,3571
-ras_commander/RasPlan.py,sha256=02agZMG29C8Ra50LSd9JF4SpomABRDJXCwNBK6dJCqM,49731
-ras_commander/RasPrj.py,sha256=LhlMR6qP9xvLMiPFuwRhRM5yosyLH2h1EyZbnhKgxE8,15163
-ras_commander/RasUnsteady.py,sha256=cOpFAZrXrxBBdoi-i3iWboQzrtCUb_sPGQ05dZnadF4,1852
-ras_commander/RasUtils.py,sha256=dkeh7k1yvrViNQ0NzG4jB4hiEvmsWZJu-_w04ccrpdI,10402
-ras_commander/__init__.py,sha256=eoOVbWnLH-e405O6ADkO6qhx45a0n60CFgFl7mj4HYs,1089
-ras_commander-0.21.0.dist-info/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
-ras_commander-0.21.0.dist-info/METADATA,sha256=F_Og5eixNK5qhCfKff4WcRWKGYX6sjKO4PrM62wf7rw,14478
-ras_commander-0.21.0.dist-info/WHEEL,sha256=muXAwoPanksrVvf9Mcykr8l6Q0JyBrGUVYr50kE4bxo,109
-ras_commander-0.21.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
-ras_commander-0.21.0.dist-info/RECORD,,