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

ras_commander/project_management.py

@@ -1,227 +0,0 @@
-"""
-Project management operations for HEC-RAS projects.
-"""
-import os
-import re
-import shutil
-from pathlib import Path
-from .file_operations import FileOperations
-from .project_config import ProjectConfig
-
-class ProjectManager:
-    """
-    A class for functions that interface with the HEC-RAS project's project file.
-    """
-    @staticmethod
-    def get_next_available_number(existing_numbers):
-        """
-        Determine the first available number for plan, unsteady, steady, or geometry files from 01 to 99.
-        Parameters:
-        existing_numbers (pandas.Series): Series of existing numbers as strings (e.g., ['01', '02', '03'])
-        Returns:
-        str: First available number as a two-digit string
-        """
-        existing_set = set(existing_numbers.astype(int))
-        for num in range(1, 100):
-            if num not in existing_set:
-                return f"{num:02d}"
-        return None
-
-    @staticmethod
-    def copy_plan_from_template(template_plan, new_plan_shortid=None):
-        """
-        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., 'p01')
-        new_plan_shortid (str, optional): New short identifier for the plan file
-        Returns:
-        str: New plan number
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-
-        new_plan_num = ProjectManager.get_next_available_number(config.ras_plan_entries['plan_number'])
-        template_plan_path = config.project_folder / f"{config.project_name}.{template_plan}"
-        new_plan_path = config.project_folder / f"{config.project_name}.p{new_plan_num}"
-        shutil.copy(template_plan_path, new_plan_path)
-        print(f"Copied {template_plan_path} to {new_plan_path}")
-
-        with open(new_plan_path, 'r') as f:
-            plan_lines = f.readlines()
-
-        shortid_pattern = re.compile(r'^Short Identifier=(.*)$', re.IGNORECASE)
-        for i, line in enumerate(plan_lines):
-            match = shortid_pattern.match(line.strip())
-            if match:
-                current_shortid = match.group(1)
-                if new_plan_shortid is None:
-                    new_shortid = (current_shortid + "_copy")[:24]
-                else:
-                    new_shortid = new_plan_shortid[:24]
-                plan_lines[i] = f"Short Identifier={new_shortid}\n"
-                break
-
-        with open(new_plan_path, 'w') as f:
-            f.writelines(plan_lines)
-
-        print(f"Updated short identifier in {new_plan_path}")
-
-        with open(config.project_file, 'r') as f:
-            lines = f.readlines()
-
-        new_plan_line = f"Plan File=p{new_plan_num}\n"
-        plan_file_pattern = re.compile(r'^Plan File=p(\d+)', re.IGNORECASE)
-        insertion_index = None
-        for i, line in enumerate(lines):
-            match = plan_file_pattern.match(line.strip())
-            if match:
-                current_number = int(match.group(1))
-                if current_number > int(new_plan_num):
-                    insertion_index = i
-                    break
-
-        if insertion_index is not None:
-            lines.insert(insertion_index, new_plan_line)
-        else:
-            last_plan_index = max([i for i, line in enumerate(lines) if plan_file_pattern.match(line.strip())], default=-1)
-            if last_plan_index != -1:
-                lines.insert(last_plan_index + 1, new_plan_line)
-            else:
-                lines.append(new_plan_line)
-
-        with open(config.project_file, 'w') as f:
-            f.writelines(lines)
-
-        print(f"Updated {config.project_file} with new plan p{new_plan_num}")
-        return f"p{new_plan_num}"
-
-    @staticmethod
-    def copy_geometry_from_template(template_geom):
-        """
-        Copy geometry files from a template, find the next geometry number,
-        and update the project file accordingly.
-        Parameters:
-        template_geom (str): Geometry number to be used as a template (e.g., 'g01')
-        Returns:
-        str: New geometry number (e.g., 'g03')
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-
-        template_geom_filename = f"{config.project_name}.{template_geom}"
-        template_geom_path = config.project_folder / template_geom_filename
-
-        if not template_geom_path.is_file():
-            raise FileNotFoundError(f"Template geometry file '{template_geom_path}' does not exist.")
-
-        template_hdf_path = template_geom_path.with_suffix('.hdf')
-        if not template_hdf_path.is_file():
-            raise FileNotFoundError(f"Template geometry .hdf file '{template_hdf_path}' does not exist.")
-
-        next_geom_number = ProjectManager.get_next_available_number(config.ras_geom_entries['geom_number'])
-
-        new_geom_filename = f"{config.project_name}.g{next_geom_number}"
-        new_geom_path = config.project_folder / new_geom_filename
-
-        shutil.copyfile(template_geom_path, new_geom_path)
-        print(f"Copied '{template_geom_path}' to '{new_geom_path}'.")
-
-        new_hdf_path = new_geom_path.with_suffix('.hdf')
-        shutil.copyfile(template_hdf_path, new_hdf_path)
-        print(f"Copied '{template_hdf_path}' to '{new_hdf_path}'.")
-
-        with open(config.project_file, 'r') as file:
-            lines = file.readlines()
-
-        new_geom_line = f"Geom File=g{next_geom_number}\n"
-        geom_file_pattern = re.compile(r'^Geom File=g(\d+)', re.IGNORECASE)
-        insertion_index = None
-        for i, line in enumerate(lines):
-            match = geom_file_pattern.match(line.strip())
-            if match:
-                current_number = int(match.group(1))
-                if current_number > int(next_geom_number):
-                    insertion_index = i
-                    break
-
-        if insertion_index is not None:
-            lines.insert(insertion_index, new_geom_line)
-        else:
-            header_pattern = re.compile(r'^(Proj Title|Current Plan|Default Exp/Contr|English Units)', re.IGNORECASE)
-            header_indices = [i for i, line in enumerate(lines) if header_pattern.match(line.strip())]
-            if header_indices:
-                last_header_index = header_indices[-1]
-                lines.insert(last_header_index + 2, new_geom_line)
-            else:
-                lines.insert(0, new_geom_line)
-
-        with open(config.project_file, 'w') as file:
-            file.writelines(lines)
-
-        print(f"Inserted 'Geom File=g{next_geom_number}' into project file '{config.project_file}'.")
-        return f"g{next_geom_number}"
-
-    @staticmethod
-    def copy_unsteady_from_template(template_unsteady):
-        """
-        Copy unsteady flow files from a template, find the next unsteady number,
-        and update the project file accordingly.
-        Parameters:
-        template_unsteady (str): Unsteady flow number to be used as a template (e.g., 'u01')
-        Returns:
-        str: New unsteady flow number (e.g., 'u03')
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-
-        template_unsteady_filename = f"{config.project_name}.{template_unsteady}"
-        template_unsteady_path = config.project_folder / template_unsteady_filename
-
-        if not template_unsteady_path.is_file():
-            raise FileNotFoundError(f"Template unsteady flow file '{template_unsteady_path}' does not exist.")
-
-        next_unsteady_number = ProjectManager.get_next_available_number(config.ras_unsteady_entries['unsteady_number'])
-
-        new_unsteady_filename = f"{config.project_name}.u{next_unsteady_number}"
-        new_unsteady_path = config.project_folder / new_unsteady_filename
-
-        shutil.copyfile(template_unsteady_path, new_unsteady_path)
-        print(f"Copied '{template_unsteady_path}' to '{new_unsteady_path}'.")
-
-        template_hdf_path = template_unsteady_path.with_suffix('.hdf')
-        new_hdf_path = new_unsteady_path.with_suffix('.hdf')
-
-        if template_hdf_path.is_file():
-            shutil.copyfile(template_hdf_path, new_hdf_path)
-            print(f"Copied '{template_hdf_path}' to '{new_hdf_path}'.")
-        else:
-            print(f"No corresponding '.hdf' file found for '{template_unsteady_filename}'. Skipping '.hdf' copy.")
-
-        with open(config.project_file, 'r') as file:
-            lines = file.readlines()
-
-        new_unsteady_line = f"Unsteady File=u{next_unsteady_number}\n"
-        unsteady_file_pattern = re.compile(r'^Unsteady File=u(\d+)', re.IGNORECASE)
-        insertion_index = None
-        for i, line in enumerate(lines):
-            match = unsteady_file_pattern.match(line.strip())
-            if match:
-                current_number = int(match.group(1))
-                if current_number > int(next_unsteady_number):
-                    insertion_index = i
-                    break
-
-        if insertion_index is not None:
-            lines.insert(insertion_index, new_unsteady_line)
-        else:
-            last_unsteady_index = max([i for i, line in enumerate(lines) if unsteady_file_pattern.match(line.strip())], default=-1)
-            if last_unsteady_index != -1:
-                lines.insert(last_unsteady_index + 1, new_unsteady_line)
-            else:
-                lines.append(new_unsteady_line)
-
-        with open(config.project_file, 'w') as file:
-            file.writelines(lines)
-
-        print(f"Inserted 'Unsteady File=u{next_unsteady_number}' into project file '{config.project_file}'.")
-        return f"u{next_unsteady_number}"

ras_commander/project_setup.py

@@ -1,15 +0,0 @@
-# REVISION NOTE: We should be able to move these functions into the project_management.py file and delete this file. 
-
-from pathlib import Path
-from .file_operations import FileOperations
-
-def find_hecras_project_file(folder_path):
-    return FileOperations.find_hecras_project_file(folder_path)
-
-def load_project_data(project_file):
-    return {
-        'ras_plan_entries': FileOperations.get_plan_entries(project_file),
-        'ras_flow_entries': FileOperations.get_flow_entries(project_file),
-        'ras_unsteady_entries': FileOperations.get_unsteady_entries(project_file),
-        'ras_geom_entries': FileOperations.get_geom_entries(project_file)
-    }

ras_commander/unsteady_operations.py

@@ -1,172 +0,0 @@
-"""
-Operations for handling unsteady flow files in HEC-RAS projects.
-"""
-from pathlib import Path
-from .project_config import ProjectConfig
-import re
-
-class UnsteadyOperations:
-    """
-    Class for all operations related to HEC-RAS unsteady flow files.
-    """
-    @staticmethod
-    def copy_unsteady_files(dst_folder, template_unsteady):
-        """
-        Copy unsteady flow files from a template to the next available unsteady number
-        and update the destination folder accordingly.
-
-        Parameters:
-        dst_folder (str): Destination folder path
-        template_unsteady (str): Template unsteady flow number (e.g., 'u01')
-
-        Returns:
-        str: New unsteady flow number (e.g., 'u03')
-        """
-        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 unsteady number
-        existing_numbers = []
-        unsteady_file_pattern = re.compile(r'^Flow File=u(\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 = unsteady_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_unsteady_number = f"{next_number:02d}"
-
-        # Copy the template unsteady file to the new unsteady file
-        template_unsteady_filename = f"{config.project_name}.u{template_unsteady}"
-        src_u_file = src_folder / template_unsteady_filename
-        if src_u_file.exists():
-            new_unsteady_filename = f"{config.project_name}.u{next_unsteady_number}"
-            dst_u_file = dst_folder / new_unsteady_filename
-            dst_u_file.write_bytes(src_u_file.read_bytes())
-            print(f"Copied {src_u_file} to {dst_u_file}")
-        else:
-            raise FileNotFoundError(f"Template unsteady file '{src_u_file}' does not exist.")
-
-        # Copy the corresponding .hdf file
-        src_hdf_file = src_folder / f"{template_unsteady_filename}.hdf"
-        if src_hdf_file.exists():
-            new_hdf_filename = f"{new_unsteady_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:
-            print(f"No corresponding .hdf file found for '{template_unsteady_filename}'. Skipping '.hdf' copy.")
-        config = ProjectConfig()
-        return f"u{next_unsteady_number}"
-
-    @staticmethod
-    def rename_unsteady_files(old_number, new_number):
-        """
-        Rename unsteady flow files in the project folder.
-        Parameters:
-        old_number (str): Old unsteady flow number (e.g., 'u01')
-        new_number (str): New unsteady flow number (e.g., 'u02')
-        Returns:
-        None
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        folder = config.project_folder
-        old_u_file = next(folder.glob(f"*.{old_number}"), None)
-        if old_u_file:
-            new_u_file = folder / old_u_file.name.replace(old_number, new_number)
-            old_u_file.rename(new_u_file)
-            print(f"Renamed {old_u_file} to {new_u_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_unsteady_reference_in_plan(plan_file, new_unsteady_number):
-        """
-        Update the unsteady flow reference in a plan file.
-        
-        Parameters:
-        plan_file (str): Full path to the plan file
-        new_unsteady_number (str): New unsteady flow number (e.g., 'u02')
-        
-        Returns:
-        None
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        plan_path = Path(plan_file)
-        if not plan_path.is_file():
-            raise FileNotFoundError(f"Plan file '{plan_path}' not found. Check that the file exists.")
-        
-        with open(plan_path, 'r') as f:
-            lines = f.readlines()
-        updated = False
-        for i, line in enumerate(lines):
-            if line.startswith("Unsteady File=") or line.startswith("Flow File=u"):
-                lines[i] = f"Unsteady File={new_unsteady_number}\n"
-                updated = True
-                break
-        if updated:
-            with open(plan_path, 'w') as f:
-                f.writelines(lines)
-            print(f"Updated unsteady flow reference in {plan_file} to {new_unsteady_number}")
-        else:
-            print(f"No unsteady flow reference found in {plan_file}")
-            
-    @staticmethod
-    def modify_unsteady_flow_parameters(unsteady_file, modifications):
-        """
-        Modify parameters in an unsteady flow file.
-        Parameters:
-        unsteady_file (str): Full path to the unsteady flow file
-        modifications (dict): Dictionary of modifications to apply, where keys are parameter names and values are new values
-        Returns:
-        None
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        unsteady_path = Path(unsteady_file)
-        with open(unsteady_path, 'r') as f:
-            lines = f.readlines()
-        updated = False
-        for i, line in enumerate(lines):
-            for param, new_value in modifications.items():
-                if line.startswith(f"{param}="):
-                    lines[i] = f"{param}={new_value}\n"
-                    updated = True
-                    print(f"Updated {param} to {new_value}")
-        if updated:
-            with open(unsteady_path, 'w') as f:
-                f.writelines(lines)
-            print(f"Applied modifications to {unsteady_file}")
-        else:
-            print(f"No matching parameters found in {unsteady_file}")

ras_commander/utilities.py

@@ -1,195 +0,0 @@
-"""
-Utility functions for the ras_commander library.
-"""
-import shutil
-import logging
-import time
-from pathlib import Path
-from .project_config import ProjectConfig
-
-class Utilities:
-    """
-    A class containing the 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, backup_suffix="_backup"):
-        """
-        Create a backup of the specified file.
-        Parameters:
-        file_path (str): Path to the file to be backed up
-        backup_suffix (str): Suffix to append to the backup file name
-        Returns:
-        str: Path to the created backup file
-        """
-        config = ProjectConfig()
-        config.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)
-        print(f"Backup created: {backup_path}")
-        return str(backup_path)
-
-    @staticmethod
-    def restore_from_backup(backup_path, remove_backup=True):
-        """
-        Restore a file from its backup.
-        Parameters:
-        backup_path (str): Path to the backup file
-        remove_backup (bool): Whether to remove the backup file after restoration
-        Returns:
-        str: Path to the restored file
-        """
-        config = ProjectConfig()
-        config.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)
-        print(f"File restored: {original_path}")
-        if remove_backup:
-            backup_path.unlink()
-            print(f"Backup removed: {backup_path}")
-        return str(original_path)
-
-    @staticmethod
-    def safe_remove(file_path):
-        """
-        Safely remove a file if it exists.
-        Parameters:
-        file_path (str): Path to the file to be removed
-        Returns:
-        bool: True if the file was removed, False if it didn't exist
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        path = Path(file_path)
-        if path.exists():
-            path.unlink()
-            print(f"File removed: {path}")
-            return True
-        else:
-            print(f"File not found: {path}")
-            return False
-
-    @staticmethod
-    def ensure_directory(directory_path):
-        """
-        Ensure that a directory exists, creating it if necessary.
-        Parameters:
-        directory_path (str): Path to the directory
-        Returns:
-        str: Path to the ensured directory
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        path = Path(directory_path)
-        path.mkdir(parents=True, exist_ok=True)
-        print(f"Directory ensured: {path}")
-        return str(path)
-
-    @staticmethod
-    def list_files_with_extension(extension):
-        """
-        List all files in the project directory with a specific extension.
-        Parameters:
-        extension (str): File extension to filter (e.g., '.prj')
-        Returns:
-        list: List of file paths matching the extension
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        files = list(config.project_folder.glob(f"*{extension}"))
-        return [str(file) for file in files]
-
-    @staticmethod
-    def get_file_size(file_path):
-        """
-        Get the size of a file in bytes.
-        Parameters:
-        file_path (str): Path to the file
-        Returns:
-        int: Size of the file in bytes
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        path = Path(file_path)
-        if path.exists():
-            size = path.stat().st_size
-            print(f"File size: {size} bytes")
-            return size
-        else:
-            print(f"File not found: {path}")
-            return None
-
-    @staticmethod
-    def get_modification_time(file_path):
-        """
-        Get the last modification time of a file.
-        Parameters:
-        file_path (str): Path to the file
-        Returns:
-        float: Last modification time as a timestamp
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        path = Path(file_path)
-        if path.exists():
-            mtime = path.stat().st_mtime
-            print(f"Last modified: {mtime}")
-            return mtime
-        else:
-            print(f"File not found: {path}")
-            return None
-
-    @staticmethod
-    def get_plan_path(current_plan_number):
-        """
-        Get the path for a plan file with a given plan number.
-        Parameters:
-        current_plan_number (str or int): The plan number (01 to 99)
-        Returns:
-        str: Full path to the plan file with the given plan number
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        current_plan_number = f"{int(current_plan_number):02d}"  # Ensure two-digit format
-        plan_name = f"{config.project_name}.p{current_plan_number}"
-        return str(config.project_folder / plan_name)
-
-    @staticmethod
-    def retry_remove_folder(folder_path: str, max_attempts: int = 5, initial_delay: float = 1.0) -> bool:
-        """
-        Attempts to remove a folder with retry logic and exponential backoff.
-        Args:
-            folder_path (str): Path to the folder to be removed.
-            max_attempts (int): Maximum number of removal attempts.
-            initial_delay (float): Initial delay between attempts in seconds.
-        Returns:
-            bool: True if the folder was successfully removed, False otherwise.
-        """
-        config = ProjectConfig()
-        config.check_initialized()
-        
-        folder = Path(folder_path)
-        for attempt in range(max_attempts):
-            try:
-                if folder.exists():
-                    shutil.rmtree(folder)
-                return True
-            except PermissionError:
-                if attempt < max_attempts - 1:
-                    delay = initial_delay * (2 ** attempt)  # Exponential backoff
-                    logging.warning(f"Failed to remove folder {folder}. Retrying in {delay} seconds...")
-                    time.sleep(delay)
-                else:
-                    logging.error(f"Failed to remove folder {folder} after {max_attempts} attempts. Skipping.")
-                    return False
-        return False