ras-commander 0.1.0__py2.py3-none-any.whl

ras_commander/geometry_operations.py

@@ -0,0 +1,184 @@
+"""
+Operations for handling geometry files in HEC-RAS projects.
+"""
+from pathlib import Path
+from .plan_operations import PlanOperations
+from .file_operations import FileOperations
+from .project_config import ProjectConfig
+import re
+
+class GeometryOperations:
+    """
+    A class for operations on HEC-RAS geometry files.
+    """
+    @staticmethod
+    def clear_geometry_preprocessor_files(plan_file):
+        """
+        Clear HEC-RAS geometry preprocessor files for a given plan file.
+        
+        Parameters:
+        plan_file (str): Full path to the HEC-RAS plan file (.p*)
+        
+        Returns:
+        None
+        """
+        config = ProjectConfig()
+        config.check_initialized()
+        
+        plan_path = Path(plan_file)
+        geom_preprocessor_file = plan_path.with_suffix('.c' + plan_path.suffix[2:])
+        if geom_preprocessor_file.exists():
+            print(f"Deleting geometry preprocessor file: {geom_preprocessor_file}")
+            geom_preprocessor_file.unlink()
+            print("File deletion completed successfully.")
+        else:
+            print(f"No geometry preprocessor file found for: {plan_file}")
+
+    @staticmethod
+    def clear_geometry_preprocessor_files_for_all_plans():
+        """
+        Clear HEC-RAS geometry preprocessor files for all plan files in the project directory.
+        
+        Returns:
+        None
+        """
+        config = ProjectConfig()
+        config.check_initialized()
+        
+        for plan_file in config.project_folder.glob("*.p[0-9][0-9]"):
+            GeometryOperations.clear_geometry_preprocessor_files(plan_file)
+
+    @staticmethod
+    def copy_geometry_files(dst_folder, template_geom):
+        """
+        Copy geometry files from a template to the next available geometry number
+        and update the destination folder accordingly.
+
+        Parameters:
+        dst_folder (str): Destination folder path
+        template_geom (str): Template geometry number (e.g., 'g01')
+
+        Returns:
+        str: New geometry number (e.g., 'g03')
+        """
+        config = ProjectConfig()
+        config.check_initialized()
+
+        src_folder = config.project_folder
+        dst_folder = Path(dst_folder)
+        dst_folder.mkdir(parents=True, exist_ok=True)
+
+        # Determine the next available geometry number
+        existing_numbers = []
+        geom_file_pattern = re.compile(r'^Geom File=g(\d+)', re.IGNORECASE)
+
+        for plan_file in src_folder.glob("*.p[0-9][0-9]"):
+            with open(plan_file, 'r') as file:
+                lines = file.readlines()
+                for line in lines:
+                    match = geom_file_pattern.match(line.strip())
+                    if match:
+                        existing_numbers.append(int(match.group(1)))
+
+        if existing_numbers:
+            existing_numbers.sort()
+            next_number = 1
+            for num in existing_numbers:
+                if num == next_number:
+                    next_number += 1
+                else:
+                    break
+        else:
+            next_number = 1
+
+        next_geom_number = f"{next_number:02d}"
+
+        # Copy the template geometry file to the new geometry file
+        template_geom_filename = f"{config.project_name}.g{template_geom}"
+        src_g_file = src_folder / template_geom_filename
+        if src_g_file.exists():
+            new_geom_filename = f"{config.project_name}.g{next_geom_number}"
+            dst_g_file = dst_folder / new_geom_filename
+            dst_g_file.write_bytes(src_g_file.read_bytes())
+            print(f"Copied {src_g_file} to {dst_g_file}")
+        else:
+            raise FileNotFoundError(f"Template geometry file '{src_g_file}' does not exist.")
+
+        # Copy the corresponding .hdf file
+        src_hdf_file = src_folder / f"{template_geom_filename}.hdf"
+        if src_hdf_file.exists():
+            new_hdf_filename = f"{new_geom_filename}.hdf"
+            dst_hdf_file = dst_folder / new_hdf_filename
+            dst_hdf_file.write_bytes(src_hdf_file.read_bytes())
+            print(f"Copied {src_hdf_file} to {dst_hdf_file}")
+        else:
+            raise FileNotFoundError(f"Template geometry .hdf file '{src_hdf_file}' does not exist.")
+        config = ProjectConfig()
+        return f"g{next_geom_number}"
+
+    @staticmethod
+    def rename_geometry_files(old_number, new_number):
+        """
+        Rename geometry files in the project folder.
+        
+        Parameters:
+        old_number (str): Old geometry number (e.g., 'g01')
+        new_number (str): New geometry number (e.g., 'g02')
+        
+        Returns:
+        None
+        """
+        config = ProjectConfig()
+        config.check_initialized()
+        
+        folder = config.project_folder
+        old_g_file = next(folder.glob(f"*.{old_number}"), None)
+        if old_g_file:
+            new_g_file = folder / old_g_file.name.replace(old_number, new_number)
+            old_g_file.rename(new_g_file)
+            print(f"Renamed {old_g_file} to {new_g_file}")
+        else:
+            print(f"No .{old_number} file found in {folder}")
+        
+        old_hdf_file = next(folder.glob(f"*.{old_number}.hdf"), None)
+        if old_hdf_file:
+            new_hdf_file = folder / old_hdf_file.name.replace(old_number, new_number)
+            old_hdf_file.rename(new_hdf_file)
+            print(f"Renamed {old_hdf_file} to {new_hdf_file}")
+        else:
+            print(f"No .{old_number}.hdf file found in {folder}")
+
+    @staticmethod
+    def update_geometry_reference_in_plan(plan_file, new_geometry_number):
+        """
+        Update the geometry reference in a plan file.
+        
+        Parameters:
+        plan_file (str): Full path to the plan file
+        new_geometry_number (str): New geometry number (e.g., 'g02')
+        
+        Returns:
+        None
+        """
+        config = ProjectConfig()
+        config.check_initialized()
+        
+        geometry_full_path = next(config.project_folder.glob(f"*.g{new_geometry_number}"), None)
+        if not geometry_full_path:
+            raise FileNotFoundError(f"Geometry file '*.g{new_geometry_number}' not found in the project folder.")
+        
+        plan_path = Path(plan_file)
+        with open(plan_path, 'r') as file:
+            lines = file.readlines()
+        updated = False
+        for index, line in enumerate(lines):
+            if line.startswith("Geom File="):
+                lines[index] = f"Geom File=g{new_geometry_number}\n"
+                updated = True
+                break
+        if updated:
+            with open(plan_path, 'w') as file:
+                file.writelines(lines)
+            print(f"Updated geometry reference in {plan_file} to {new_geometry_number}")
+        else:
+            print(f"No geometry reference found in {plan_file}")

ras_commander/plan_operations.py

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

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