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

ras_commander/plan_operations.py

@@ -1,307 +0,0 @@
-"""
-Operations for modifying and updating HEC-RAS plan files.
-"""
-import re
-from pathlib import Path
-
-
-from .project_config import ProjectConfig
-
-class PlanOperations:
-    """
-    A class for operations on HEC-RAS plan files.
-    """
-    @staticmethod
-    def apply_geometry_to_plan(plan_file, geometry_number):
-        """
-        Apply a geometry file to a plan file.
-        
-        Parameters:
-        plan_file (str): Full path to the HEC-RAS plan file (.pXX)
-        geometry_number (str): Geometry number to apply (e.g., '01')
-        
-        Returns:
-        None
-
-        Raises:
-        ValueError: If the specified geometry number is not found in the project file
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        if f"g{geometry_number}" not in config.ras_geom_entries['geom_number'].values:
-            raise ValueError(f"Geometry number g{geometry_number} not found in project file.")
-        with open(plan_file, 'r') as f:
-            lines = f.readlines()
-        with open(plan_file, 'w') as f:
-            for line in lines:
-                if line.startswith("Geom File="):
-                    f.write(f"Geom File=g{geometry_number}\n")
-                    print(f"Updated Geom File in {plan_file} to g{geometry_number}")
-                else:
-                    f.write(line)
-
-    @staticmethod
-    def apply_flow_to_plan(plan_file, flow_number):
-        """
-        Apply a steady flow file to a plan file.
-        
-        Parameters:
-        plan_file (str): Full path to the HEC-RAS plan file (.pXX)
-        flow_number (str): Flow number to apply (e.g., '02')
-        
-        Returns:
-        None
-
-        Raises:
-        ValueError: If the specified flow number is not found in the project file
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        if f"{flow_number}" not in config.ras_flow_entries['flow_number'].values:
-            raise ValueError(f"Flow number f{flow_number} not found in project file.")
-        with open(plan_file, 'r') as f:
-            lines = f.readlines()
-        with open(plan_file, 'w') as f:
-            for line in lines:
-                if line.startswith("Flow File="):
-                    f.write(f"Flow File=f{flow_number}\n")
-                    print(f"Updated Flow File in {plan_file} to f{flow_number}")
-                else:
-                    f.write(line)
-                    
-    @staticmethod
-    def copy_plan_from_template(template_plan):
-        """
-        Create a new plan file based on a template and update the project file.
-        
-        Parameters:
-
-        template_plan (str): Plan file to use as template (e.g., '01')
-        project_folder, project_name, 
-        Returns:
-        str: New plan number
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-
-        # Read existing plan numbers
-        ras_plan_entries = config.ras_plan_entries
-
-        # Get next available plan number
-        new_plan_num = PlanOperations.get_next_available_number(ras_plan_entries['plan_number'])
-
-        # Copy template plan file to new plan file
-        template_plan_path = Path(config.project_folder) / f"{config.project_name}.p{template_plan}"
-        new_plan_path = Path(config.project_folder) / f"{config.project_name}.p{new_plan_num}"
-        new_plan_path.write_bytes(template_plan_path.read_bytes())
-        print(f"Copied {template_plan_path} to {new_plan_path}")
-
-        # Update project file with new plan
-        project_file = config.project_file
-        with open(project_file, 'a') as f:
-            f.write(f"\nPlan File=p{new_plan_num}")
-        print(f"Updated {project_file} with new plan p{new_plan_num}")
-        config = ProjectConfig()
-        return f"{new_plan_num}"
-
-    @staticmethod
-    def get_next_available_number(existing_numbers):
-        """
-        Determine the next available number from a list of existing numbers.
-        
-        Parameters:
-        existing_numbers (list): List of existing numbers as strings
-        
-        Returns:
-        str: Next available number as a zero-padded string
-        """
-        existing_numbers = sorted(int(num) for num in existing_numbers)
-        next_number = 1
-        for num in existing_numbers:
-            if num == next_number:
-                next_number += 1
-            else:
-                break
-        return f"{next_number:02d}"
-
-
-
-    @staticmethod
-    def apply_unsteady_to_plan(plan_file, unsteady_number):
-        """
-        Apply an unsteady flow file to a plan file.
-        
-        Parameters:
-        plan_file (str): Full path to the HEC-RAS plan file (.pXX)
-        unsteady_number (str): Unsteady flow number to apply (e.g., '01')
-        
-        Returns:
-        None
-
-        Raises:
-        ValueError: If the specified unsteady number is not found in the project file
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        if f"u{unsteady_number}" not in config.ras_unsteady_entries['unsteady_number'].values:
-            raise ValueError(f"Unsteady number u{unsteady_number} not found in project file.")
-        with open(plan_file, 'r') as f:
-            lines = f.readlines()
-        with open(plan_file, 'w') as f:
-            for line in lines:
-                if line.startswith("Unsteady File=") or line.startswith("Flow File=u"):
-                    f.write(f"Unsteady File=u{unsteady_number}\n")
-                    print(f"Updated Unsteady File in {plan_file} to u{unsteady_number}")
-                else:
-                    f.write(line)
-
-    @staticmethod
-    def set_num_cores(plan_file, num_cores):
-        """
-        Update the maximum number of cores to use in the HEC-RAS plan file.
-        
-        Parameters:
-        plan_file (str): Full path to the plan file
-        num_cores (int): Maximum number of cores to use
-        
-        Returns:
-        None
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        cores_pattern = re.compile(r"(UNET D1 Cores= )\d+")
-        with open(plan_file, 'r') as file:
-            content = file.read()
-        new_content = cores_pattern.sub(rf"\g<1>{num_cores}", content)
-        with open(plan_file, 'w') as file:
-            file.write(new_content)
-        print(f"Updated {plan_file} with {num_cores} cores.")
-
-    @staticmethod
-    def update_geompre_flags(file_path, run_htab_value, use_ib_tables_value):
-        """
-        Update the simulation plan file to modify the `Run HTab` and `UNET Use Existing IB Tables` settings.
-        
-        Parameters:
-        file_path (str): Path to the simulation plan file (.p06 or similar) that you want to modify.
-        run_htab_value (int): Value for the `Run HTab` setting:
-            - `0` : Do not run the geometry preprocessor, use existing geometry tables.
-            - `-1` : Run the geometry preprocessor, forcing a recomputation of the geometry tables.
-        use_ib_tables_value (int): Value for the `UNET Use Existing IB Tables` setting:
-            - `0` : Use existing interpolation/boundary (IB) tables without recomputing them.
-            - `-1` : Do not use existing IB tables, force a recomputation.
-        
-        Returns:
-        None
-
-        Raises:
-        ValueError: If `run_htab_value` or `use_ib_tables_value` are not integers or not within the accepted values (`0` or `-1`).
-        FileNotFoundError: If the specified file does not exist.
-        IOError: If there is an error reading or writing the file.
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        if run_htab_value not in [-1, 0]:
-            raise ValueError("Invalid value for `Run HTab`. Expected `0` or `-1`.")
-        if use_ib_tables_value not in [-1, 0]:
-            raise ValueError("Invalid value for `UNET Use Existing IB Tables`. Expected `0` or `-1`.")
-        try:
-            print(f"Reading the file: {file_path}")
-            with open(file_path, 'r') as file:
-                lines = file.readlines()
-            print("Updating the file with new settings...")
-            updated_lines = []
-            for line in lines:
-                if line.strip().startswith("Run HTab="):
-                    updated_line = f"Run HTab= {run_htab_value} \n"
-                    updated_lines.append(updated_line)
-                    print(f"Updated 'Run HTab' to {run_htab_value}")
-                elif line.strip().startswith("UNET Use Existing IB Tables="):
-                    updated_line = f"UNET Use Existing IB Tables= {use_ib_tables_value} \n"
-                    updated_lines.append(updated_line)
-                    print(f"Updated 'UNET Use Existing IB Tables' to {use_ib_tables_value}")
-                else:
-                    updated_lines.append(line)
-            print(f"Writing the updated settings back to the file: {file_path}")
-            with open(file_path, 'w') as file:
-                file.writelines(updated_lines)
-            print("File update completed successfully.")
-        except FileNotFoundError:
-            raise FileNotFoundError(f"The file '{file_path}' does not exist.")
-        except IOError as e:
-            raise IOError(f"An error occurred while reading or writing the file: {e}")
-
-    @staticmethod
-    def get_plan_full_path(plan_number: str) -> str:
-        """Return the full path for a given plan number."""
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        plan_path = config.ras_plan_entries[config.ras_plan_entries['plan_number'] == plan_number]
-        if not plan_path.empty:
-            return plan_path['full_path'].iloc[0]
-        else:
-            raise ValueError(f"Plan number {plan_number} not found.")
-
-    @staticmethod
-    def get_results_full_path(plan_number: str) -> str:
-        """Return the results path for a given plan number."""
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        results_path = config.ras_plan_entries[config.ras_plan_entries['plan_number'] == plan_number]
-        if not results_path.empty:
-            results_file_path = Path(results_path['results_path'].iloc[0])
-            if results_file_path.exists():
-                print(f"Results file for Plan number {plan_number} exists at: {results_file_path}")
-                return str(results_file_path)
-            else:
-                print(f"Error: Results file for Plan number {plan_number} does not exist at the expected location: {results_file_path}")
-                return None
-        else:
-            print(f"Error: Results file for Plan number {plan_number} not found in the entries.")
-            return None
-
-
-
-
-    @staticmethod
-    def get_flow_full_path(flow_number: str) -> str:
-        """Return the full path for a given flow number."""
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        flow_path = config.ras_flow_entries[config.ras_flow_entries['flow_number'] == flow_number]
-        if not flow_path.empty:
-            return flow_path['full_path'].iloc[0]
-        else:
-            raise ValueError(f"Flow number {flow_number} not found.")
-
-    @staticmethod
-    def get_unsteady_full_path(unsteady_number: str) -> str:
-        """Return the full path for a given unsteady number."""
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        unsteady_path = config.ras_unsteady_entries[config.ras_unsteady_entries['unsteady_number'] == unsteady_number]
-        if not unsteady_path.empty:
-            return unsteady_path['full_path'].iloc[0]
-        else:
-            raise ValueError(f"Unsteady number {unsteady_number} not found.")
-
-    @staticmethod
-    def get_geom_full_path(geometry_number: str) -> str:
-        """Return the full path for a given geometry number."""
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        geom_path = config.ras_geom_entries[config.ras_geom_entries['geom_number'] == geometry_number]
-        if not geom_path.empty:
-            return geom_path['full_path'].iloc[0]
-        else:
-            raise ValueError(f"Geometry number {geometry_number} not found.")

ras_commander/project_config.py

@@ -1,64 +0,0 @@
-from pathlib import Path
-from .project_setup import find_hecras_project_file, load_project_data
-
-# Notes (do note delete):
-# This ProjectConfig class is a singleton, so it will have the same values for all instances.
-# The class is very important for the project setup, as it will be used to store all the project's basic information.
-# Instead of having to pass around the project folder, project file, etc., we can just pass around the ProjectConfig class instance.
-# The class will need to be initialized with the project folder, which will then be used to set all the other project information.
-# The project information will be stored in the instance as class variables.
-
-# Documentation Notes: 
-# print each variable name and value after it is defined, so the user can easily reference the project's basic information using the self. class variables 
-# example: print(f"self.project_file: {self.project_file}")
-
-class ProjectConfig:
-    _instance = None
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(ProjectConfig, cls).__new__(cls)
-            cls._instance.initialized = False
-        return cls._instance
-
-    def initialize(self, project_folder, hecras_exe_path):
-        self.project_folder = Path(project_folder)
-        print(f"self.project_folder: {self.project_folder}")
-        
-        self.project_file = find_hecras_project_file(self.project_folder)
-        print(f"self.project_file: {self.project_file}")
-        
-        if self.project_file is None:
-            raise ValueError(f"No HEC-RAS project file found in {self.project_folder}")
-        
-        self.project_name = self.project_file.stem
-        print(f"self.project_name: {self.project_name}")
-        
-        self.hecras_exe_path = hecras_exe_path
-        print(f"self.hecras_exe_path: {self.hecras_exe_path}")
-        
-        self._load_project_data()
-        self.initialized = True
-        print(f"self.initialized: {self.initialized}")
-
-    def _load_project_data(self):
-        data = load_project_data(self.project_file)
-        self.ras_plan_entries = data['ras_plan_entries']
-        print(f"self.ras_plan_entries: {self.ras_plan_entries}")
-        
-        self.ras_flow_entries = data['ras_flow_entries']
-        print(f"self.ras_flow_entries: {self.ras_flow_entries}")
-        
-        self.ras_unsteady_entries = data['ras_unsteady_entries']
-        print(f"self.ras_unsteady_entries: {self.ras_unsteady_entries}")
-        
-        self.ras_geom_entries = data['ras_geom_entries']
-        print(f"self.ras_geom_entries: {self.ras_geom_entries}")
-
-    @property
-    def is_initialized(self):
-        return self.initialized
-
-    def check_initialized(self):
-        if not self.initialized:
-            raise RuntimeError("Project not initialized. Call init_ras_project() first.")

ras_commander/project_init.py

@@ -1,174 +0,0 @@
-from .project_config import ProjectConfig
-from pathlib import Path
-
-def init_ras_project(ras_project_folder, hecras_version_or_path):
-    """
-    Initialize a HEC-RAS project.
-
-    This function sets up a HEC-RAS project by validating the project folder,
-    determining the HEC-RAS executable path, and initializing the project configuration.
-
-    Args:
-        ras_project_folder (str): Path to the HEC-RAS project folder.
-        hecras_version_or_path (str): Either the HEC-RAS version number or the full path to the HEC-RAS executable.
-
-    Returns:
-        ProjectConfig: An initialized ProjectConfig object containing the project configuration.
-
-    Raises:
-        FileNotFoundError: If the specified RAS project folder does not exist.
-
-    Note:
-        This function prints a confirmation message upon successful initialization.
-        
-    Future Development Roadmap: 
-    
-    1. Load critical keys and values from the project files into the project config
-        Implemented:
-        - Project Name
-        - Project Folder
-        - Lists of plan, flow, unsteady, and geometry files
-        - HEC-RAS Executable Path
-        
-        Not Implemented:
-        - Units 
-        - Coordinate System 
-        - rasmap file path (replace prj file path extension with ".rasmap" and add it to the project config)
-        - Current Plan
-        - Description (including checks to see if it is a valid string and within the default max length)
-        - DSS Start Date=01JAN1999 (note format is MMDDYYY)
-        - DSS Start Time=1200 (note format is HHMM)
-        - DSS End Date=04JAN1999 (note format is MMDDYYY)
-        - DSS End Time=1200 (note format is HHMM)
-        - DSS File=dss
-        - DSS File=Bald_Eagle_Creek.dss 
-              
-    Other not implemented:
-    
-    2. Load critical keys and lists of string values from the plan files into the project config
-        - Plan Title
-        - Plan Shortid
-        - Simulation Date
-        - Geometry File
-        - Flow File (may not be present) - if present, the plan is a 1D steady plan
-        - Unsteady File (may not be present) - if present, the plan is a 1D or 2D unsteady plan
-        - UNET D2 Name (may not be present) - if present, the plan is a 2D plan
-        - Type (1D Steady, 1D Unsteady, 1D/2D, or 2D)
-        - UNET 1D Methodology
-       
-    3. Load critical keys and strings from the unsteady flow files into the project config
-        - Flow Title
-        - Pandas Dataframe for any Boundary Conditions present and whether they are defined in the file or whether they use a DSS file input
-           - One dataframe for all unsteady flow files, with each Boundary Location in each file having its own row
-           - For each unsteady flow filereturn an appended dataframe with each boundary condition and it's "Boundary Name", "Interval", "DSS Path", "Flow Hydrograph Slope", and whether Use DSS is True or False
-           - Need to incorporate knowledge from the excel methods we used for setting boundary conditions
-           
-    4. Load critical keys and strings from the steady flow files into the project config
-        - Flow Title
-        - Since steady models are not as commonly used, this is a low priority integration (external contributions are welcome)
-               
-    
-    5. Load critical keys and values from the rasmap file into the project config
-        - rasmap_projection_string
-        - Version   #Ex: <Version>2.0.0</Version> 
-        - RASProjectionFilename Filename=".\Terrain\Projection.prj"
-        
-        - List of ras terrains as pandas dataframes
-            - for each, list of tiff files and order
-            - flag whether terrain mods exist 
-            
-        - List of Infiltration hdf files as pandas dataframes
-            - Mapping of infiltration layers to geometries
-            
-        - List of land cover hdf files as pandas dataframes
-            - Mapping of land cover to geometries
-        
-        - List of all Mannings N layers, hdf files and mapping to geometries as pandas dataframes
-            
-    6. Create a list of all valid hdf plan files are present in the project folder, and flag whether they contain a completed simulation
-    
-    This roadmap for the project_init function will provide the basic information needed to support most basic hec-ras automation workflows.  
-    
-    Remember, this project init might be called multiple times.  Every time, it should clear any previously created datafrarmes and variables and replace them.  It is important that revisions can be made, init be re-run, and information is current and reflects the current state of the project. 
-
-        
-        
-    """
-    # Check if the provided paths exist
-    if not Path(ras_project_folder).exists():
-        raise FileNotFoundError(f"The specified RAS project folder does not exist: {ras_project_folder}, Please check the path and try again.")
-    
-    hecras_exe_path = get_hecras_exe_path(hecras_version_or_path)
-    
-    config = ProjectConfig()
-    config.initialize(ras_project_folder, hecras_exe_path)
-    print(f"HEC-RAS project initialized: {config.project_name}")
-    return config
-
-
-def get_hecras_exe_path(hecras_version_or_path):
-    """
-    Determine the HEC-RAS executable path based on the input.
-    
-    Args:
-    hecras_version_or_path (str): Either a version number or a full path to the HEC-RAS executable.
-    
-    Returns:
-    str: The full path to the HEC-RAS executable.
-    
-    Raises:
-    ValueError: If the input is neither a valid version number nor a valid file path.
-    FileNotFoundError: If the executable file does not exist at the specified or constructed path.
-    """
-    
-    
-    # hecras_exe_path should be changed to hecras_version_or_path
-    # Based on whether a full path is provided, or a version number is provided, the path will be set accordingly
-    # By default, HEC-RAS is installed in the Program Files (x86) folder 
-    # For example: hecras_exe_path = r"C:\Program Files (x86)\HEC\HEC-RAS\6.5\Ras.exe" for version 6.5
-    # an f string to build the path based on the version number
-    # hecras_exe_path = f"C:\Program Files (x86)\HEC\HEC-RAS\{hecras_version}\Ras.exe"
-    # where hecras_version is one of the following: 
-    
-    # List of HEC-RAS version numbers
-    ras_version_numbers = [
-        "6.5", "6.4.1", "6.3.1", "6.3", "6.2", "6.1", "6.0",
-        "5.0.7", "5.0.6", "5.0.5", "5.0.4", "5.0.3", "5.0.1", "5.0",
-        "4.1", "4.0", "3.1.3", "3.1.2", "3.1.1", "3.0", "2.2"
-    ]
-    
-    hecras_path = Path(hecras_version_or_path)
-    
-    # Check if the input is a full path
-    if hecras_path.is_file() and hecras_path.suffix.lower() == '.exe':
-        return str(hecras_path)
-    
-    # Check if the input is a version number
-    if hecras_version_or_path in ras_version_numbers:
-        default_path = Path(f"C:/Program Files (x86)/HEC/HEC-RAS/{hecras_version_or_path}/Ras.exe")
-        if default_path.is_file():
-            return str(default_path)
-        else:
-            raise FileNotFoundError(f"HEC-RAS executable not found at the expected path: {default_path}")
-    
-    # Check if it's a newer version
-    try:
-        version_float = float(hecras_version_or_path)
-        if version_float > max(float(v) for v in ras_version_numbers):
-            newer_version_path = Path(f"C:/Program Files (x86)/HEC/HEC-RAS/{hecras_version_or_path}/Ras.exe")
-            if newer_version_path.is_file():
-                return str(newer_version_path)
-            else:
-                raise FileNotFoundError(f"Newer version of HEC-RAS was specified. Check the version number or pass the full Ras.exe path as the function argument instead of the version number. The script looked for the executable at: {newer_version_path}")
-    except ValueError:
-        pass  # Not a valid float, so not a version number
-    
-    raise ValueError(f"Invalid HEC-RAS version or path: {hecras_version_or_path}. "
-                     f"Please provide a valid version number from {ras_version_numbers} "
-                     "or a full path to the HEC-RAS executable.")
-    # Return the validated HEC-RAS executable path
-    return hecras_exe_path
-
-
-
-