ras-commander 0.1.6__py2.py3-none-any.whl → 0.20.dev0__py2.py3-none-any.whl

ras_commander/RasUtils.py

@@ -0,0 +1,283 @@
+"""
+Utility functions for the ras_commander library.
+"""
+import shutil
+import logging
+import time
+from pathlib import Path
+from .RasPrj import ras
+
+class RasUtils:
+    """
+    A class containing utility functions for the ras_commander library.
+    When integrating new functions that do not clearly fit into other classes, add them here.
+    """
+
+    @staticmethod
+    def create_backup(file_path: Path, backup_suffix: str = "_backup", ras_object=None) -> Path:
+        """
+        Create a backup of the specified file.
+
+        Parameters:
+        file_path (Path): Path to the file to be backed up
+        backup_suffix (str): Suffix to append to the backup file name
+        ras_object (RasPrj, optional): RAS object to use. If None, uses the default ras object.
+
+        Returns:
+        Path: Path to the created backup file
+
+        Example:
+        >>> backup_path = RasUtils.create_backup(Path("project.prj"))
+        >>> print(f"Backup created at: {backup_path}")
+        """
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+        
+        original_path = Path(file_path)
+        backup_path = original_path.with_name(f"{original_path.stem}{backup_suffix}{original_path.suffix}")
+        shutil.copy2(original_path, backup_path)
+        logging.info(f"Backup created: {backup_path}")
+        return backup_path
+
+    @staticmethod
+    def restore_from_backup(backup_path: Path, remove_backup: bool = True, ras_object=None) -> Path:
+        """
+        Restore a file from its backup.
+
+        Parameters:
+        backup_path (Path): Path to the backup file
+        remove_backup (bool): Whether to remove the backup file after restoration
+        ras_object (RasPrj, optional): RAS object to use. If None, uses the default ras object.
+
+        Returns:
+        Path: Path to the restored file
+
+        Example:
+        >>> restored_path = RasUtils.restore_from_backup(Path("project_backup.prj"))
+        >>> print(f"File restored to: {restored_path}")
+        """
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+        
+        backup_path = Path(backup_path)
+        original_path = backup_path.with_name(backup_path.stem.rsplit('_backup', 1)[0] + backup_path.suffix)
+        shutil.copy2(backup_path, original_path)
+        logging.info(f"File restored: {original_path}")
+        if remove_backup:
+            backup_path.unlink()
+            logging.info(f"Backup removed: {backup_path}")
+        return original_path
+
+    @staticmethod
+    def create_directory(directory_path: Path, ras_object=None) -> Path:
+        """
+        Ensure that a directory exists, creating it if necessary.
+
+        Parameters:
+        directory_path (Path): Path to the directory
+        ras_object (RasPrj, optional): RAS object to use. If None, uses the default ras object.
+
+        Returns:
+        Path: Path to the ensured directory
+
+        Example:
+        >>> ensured_dir = RasUtils.create_directory(Path("output"))
+        >>> print(f"Directory ensured: {ensured_dir}")
+        """
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+        
+        path = Path(directory_path)
+        path.mkdir(parents=True, exist_ok=True)
+        logging.info(f"Directory ensured: {path}")
+        return path
+
+    @staticmethod
+    def find_files_by_extension(extension: str, ras_object=None) -> list:
+        """
+        List all files in the project directory with a specific extension.
+
+        Parameters:
+        extension (str): File extension to filter (e.g., '.prj')
+        ras_object (RasPrj, optional): RAS object to use. If None, uses the default ras object.
+
+        Returns:
+        list: List of file paths matching the extension
+
+        Example:
+        >>> prj_files = RasUtils.find_files_by_extension('.prj')
+        >>> print(f"Found {len(prj_files)} .prj files")
+        """
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+        
+        files = list(ras_obj.project_folder.glob(f"*{extension}"))
+        return [str(file) for file in files]
+
+    @staticmethod
+    def get_file_size(file_path: Path, ras_object=None) -> int:
+        """
+        Get the size of a file in bytes.
+
+        Parameters:
+        file_path (Path): Path to the file
+        ras_object (RasPrj, optional): RAS object to use. If None, uses the default ras object.
+
+        Returns:
+        int: Size of the file in bytes
+
+        Example:
+        >>> size = RasUtils.get_file_size(Path("project.prj"))
+        >>> print(f"File size: {size} bytes")
+        """
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+        
+        path = Path(file_path)
+        if path.exists():
+            return path.stat().st_size
+        else:
+            logging.warning(f"File not found: {path}")
+            return None
+
+    @staticmethod
+    def get_file_modification_time(file_path: Path, ras_object=None) -> float:
+        """
+        Get the last modification time of a file.
+
+        Parameters:
+        file_path (Path): Path to the file
+        ras_object (RasPrj, optional): RAS object to use. If None, uses the default ras object.
+
+        Returns:
+        float: Last modification time as a timestamp
+
+        Example:
+        >>> mtime = RasUtils.get_file_modification_time(Path("project.prj"))
+        >>> print(f"Last modified: {mtime}")
+        """
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+        
+        path = Path(file_path)
+        if path.exists():
+            return path.stat().st_mtime
+        else:
+            logging.warning(f"File not found: {path}")
+            return None
+
+    @staticmethod
+    def get_plan_path(current_plan_number: int, ras_object=None) -> Path:
+        """
+        Get the path for a plan file with a given plan number.
+
+        Parameters:
+        current_plan_number (int): The plan number (1 to 99)
+        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
+
+        Example:
+        >>> plan_path = RasUtils.get_plan_path(1)
+        >>> 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_name = f"{ras_obj.project_name}.p{current_plan_number}"
+        return ras_obj.project_folder / plan_name
+
+    @staticmethod
+    def remove_with_retry(path: Path, max_attempts: int = 5, initial_delay: float = 1.0, is_folder: bool = True, ras_object=None) -> bool:
+        """
+        Attempts to remove a file or folder with retry logic and exponential backoff.
+
+        Parameters:
+        path (Path): Path to the file or folder to be removed.
+        max_attempts (int): Maximum number of removal attempts.
+        initial_delay (float): Initial delay between attempts in seconds.
+        is_folder (bool): If True, the path is treated as a folder; if False, it's treated as a file.
+        ras_object (RasPrj, optional): RAS object to use. If None, uses the default ras object.
+
+        Returns:
+        bool: True if the file or folder was successfully removed, False otherwise.
+
+        Example:
+        >>> success = RasUtils.remove_with_retry(Path("temp_folder"), is_folder=True)
+        >>> print(f"Removal successful: {success}")
+        """
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+
+        path = Path(path)
+        for attempt in range(max_attempts):
+            try:
+                if path.exists():
+                    if is_folder:
+                        shutil.rmtree(path)
+                    else:
+                        path.unlink()
+                return True
+            except PermissionError:
+                if attempt < max_attempts - 1:
+                    delay = initial_delay * (2 ** attempt)  # Exponential backoff
+                    logging.warning(f"Failed to remove {path}. Retrying in {delay} seconds...")
+                    time.sleep(delay)
+                else:
+                    logging.error(f"Failed to remove {path} after {max_attempts} attempts. Skipping.")
+                    return False
+        return False
+
+    @staticmethod
+    def update_plan_file(plan_number: int, 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)
+        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.
+
+        Raises:
+        ValueError: If an invalid file_type is provided
+        FileNotFoundError: If the plan file doesn't exist
+
+        Example:
+        >>> update_plan_entries(1, "Geom", 2)
+        """
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+        
+        valid_file_types = {'Geom': 'g', 'Flow': 'f', 'Unsteady': 'u'}
+        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)
+        if not plan_file_path.exists():
+            raise FileNotFoundError(f"Plan file not found: {plan_file_path}")
+
+        file_prefix = valid_file_types[file_type]
+        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:
+            lines = file.readlines()
+
+        for i, line in enumerate(lines):
+            if line.startswith(search_pattern):
+                lines[i] = f"{search_pattern}{file_prefix}{entry_number}\n"
+                logging.info(f"Updated {file_type} File in {plan_file_path} to {file_prefix}{entry_number}")
+                break
+
+        with plan_file_path.open('w') as file:
+            file.writelines(lines)
+
+        logging.info(f"Successfully updated plan file: {plan_file_path}")
+        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()
+

ras_commander/__init__.py

@@ -5,3 +5,36 @@ try:
 except PackageNotFoundError:
     # package is not installed
     __version__ = "unknown"
+
+# Import all necessary functions and classes directly
+from .RasPrj import ras, init_ras_project, get_ras_exe
+from .RasPrj import RasPrj
+from .RasPlan import RasPlan
+from .RasGeo import RasGeo
+from .RasUnsteady import RasUnsteady
+from .RasCommander import RasCommander
+from .RasUtils import RasUtils
+from .RasExamples import RasExamples
+
+# Import all attributes from these modules
+from .RasPrj import *
+from .RasPrj import *
+from .RasPlan import *
+from .RasGeo import *
+from .RasUnsteady import *
+from .RasCommander import *
+from .RasUtils import *
+from .RasExamples import *
+# Define __all__ to specify what should be imported when using "from ras_commander import *"
+__all__ = [
+    "ras",
+    "init_ras_project",
+    "get_ras_exe",
+    "RasPrj",
+    "RasPlan",
+    "RasGeo",
+    "RasUnsteady",
+    "RasCommander",
+    "RasUtils",
+    "RasExamples"
+]

ras_commander/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.6'
-__version_tuple__ = version_tuple = (0, 1, 6)
+__version__ = version = '0.20.dev0'
+__version_tuple__ = version_tuple = (0, 20, 'dev0')

ras_commander-0.20.dev0.dist-info/METADATA

@@ -0,0 +1,342 @@
+Metadata-Version: 2.1
+Name: ras_commander
+Version: 0.20.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
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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 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.
+
+## Features
+
+- Automate HEC-RAS project management and simulations
+- Support for both single and multiple project instances
+- Parallel execution of HEC-RAS plans
+- Utilities for managing geometry, plan, and unsteady flow files
+- Example project management for testing and development
+- Two primary operation modes: "Run Missing" and "Build from DSS"
+
+## Installation
+
+Install ras_commander using pip:
+
+```bash
+pip install ras_commander
+```
+
+## Requirements
+
+- Python 3.9+
+- HEC-RAS 6.5 (other versions may work but are not officially supported)
+
+For a full list of dependencies, see the `requirements.txt` file.
+
+## Quick Start
+
+```python
+from ras_commander import init_ras_project, RasCommander, RasPlan
+
+# Initialize a project
+init_ras_project("/path/to/project", "6.5")
+
+# Execute a single plan
+RasCommander.compute_plan("01")
+
+# Execute plans in parallel
+results = RasCommander.compute_parallel(
+    plan_numbers=["01", "02"],
+    max_workers=2,
+    cores_per_run=2
+)
+
+# Modify a plan
+RasPlan.set_geom("01", "02")
+```
+
+## Key Components
+
+- `RasPrj`: Manages HEC-RAS projects
+- `RasCommander`: Handles execution of HEC-RAS simulations
+- `RasPlan`: Provides functions for modifying and updating plan files
+- `RasGeo`: Handles operations related to geometry files
+- `RasUnsteady`: Manages unsteady flow file operations
+- `RasUtils`: Contains utility functions for file operations and data management
+- `RasExamples`: Manages and loads HEC-RAS example projects
+
+## Documentation
+
+For detailed usage instructions and API documentation, please refer to the [Comprehensive Library Guide](Comprehensive_Library_Guide.md).
+
+## Examples
+
+Check out the `examples/` directory for sample scripts demonstrating various features of ras_commander.
+
+## Development
+
+### Setting up the development environment
+
+1. Clone the repository:
+   ```
+   git clone https://github.com/yourusername/ras_commander.git
+   ```
+2. Create a virtual environment and activate it:
+   ```
+   python -m venv venv
+   source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
+   ```
+3. Install the development dependencies:
+   ```
+   pip install -r requirements.txt
+   ```
+Certainly! I'll provide an updated Project Organization Diagram based on the current structure of the ras_commander library. Here's the updated diagram:
+
+
+## Project Organization Diagram
+
+```
+ras_commander
+├── .github
+│   └── workflows
+│       └── python-package.yml
+├── ras_commander
+│   ├── __init__.py
+│   ├── RasCommander.py
+│   ├── RasExamples.py
+│   ├── RasGeo.py
+│   ├── RasPlan.py
+│   ├── RasPrj.py
+│   ├── RasUnsteady.py
+│   └── RasUtils.py
+├── examples
+│   ├── 01_project_initialization.py
+│   ├── 02_plan_operations.py
+│   ├── 03_geometry_operations.py
+│   ├── 04_unsteady_flow_operations.py
+│   ├── 05_utility_functions.py
+│   ├── 06_single_plan_execution.py
+│   ├── 07_sequential_plan_execution.py
+│   ├── 08_parallel_execution.py
+│   ├── 09_specifying_plans.py
+│   ├── 10_arguments_for_compute.py
+│   ├── 11_Using_RasExamples.ipynb
+│   ├── 12_plan_set_execution.py
+│   └── 13_multiple_project_operations.py
+├── tests
+│   └── ... (test files)
+├── .gitignore
+├── LICENSE
+├── README.md
+├── STYLE_GUIDE.md
+├── Comprehensive_Library_Guide.md
+├── pyproject.toml
+├── setup.cfg
+├── setup.py
+└── requirements.txt
+
+
+## Inclusion of .cursorrules 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: 
+
+- ChatGPT:  ras_commander GPT Assistant (LINK HERE)
+- Latest LLM summaries of the code base:
+   - 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
+
+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.  
+
+## RAS-Commander GPT Assistant 
+
+The ras_commander GPT assistant has access the entire code base, and can be a helpful tool for understanding the library and its capabilities.  However, it is subject to the same context window limitations and file retrieval limtations as I have covered in ADD BLOG LINK HERE.  For best results, use the llm summaries above to provide robust context to the model before asking to generate complex workflows. 
+
+## Contributing
+
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details on how to submit pull requests, report issues, and suggest improvements.
+
+## Style Guide
+
+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.
+
+## Acknowledgments
+
+ras_commander is based on the HEC-Commander project's "Command Line is All You Need" approach, leveraging the HEC-RAS command-line interface for automation. The initial development of this library was presented in the HEC-Commander Tools repository.  In a 2024 Australian Water School webinar, Bill demonstrated the derivation of basic HEC-RAS automation functions from plain language instructions. Leveraging the previously developed code and AI tools, the library was created. The primary tools used for this initial development were Anthropic's Claude, GPT-4o, Google's Gemini Experimental models,and the Cursor AI Coding IDE.
+
+
+
+## Contact
+
+For questions, suggestions, or support, please contact:
+William Katzenmeyer, P.E., C.F.M. - billk@fenstermaker.com

ras_commander-0.20.dev0.dist-info/RECORD

@@ -0,0 +1,15 @@
+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/_version.py,sha256=iOPcP0PXx7hcLwhjMnFE1rJAvkL3xkJbhxo16-_guaE,421
+ras_commander-0.20.dev0.dist-info/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
+ras_commander-0.20.dev0.dist-info/METADATA,sha256=5qNozFVPJ3I0Lmjs-yDnb4XkyFnQ9Q_u4VgE6FZCZlA,14481
+ras_commander-0.20.dev0.dist-info/WHEEL,sha256=muXAwoPanksrVvf9Mcykr8l6Q0JyBrGUVYr50kE4bxo,109
+ras_commander-0.20.dev0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
+ras_commander-0.20.dev0.dist-info/RECORD,,

{ras_commander-0.1.6.dist-info → ras_commander-0.20.dev0.dist-info}/WHEEL

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