ras-commander 0.40.0__tar.gz → 0.42.0__tar.gz

{ras_commander-0.40.0/ras_commander.egg-info → ras_commander-0.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ras-commander
-Version: 0.40.0
+Version: 0.42.0
 Summary: A Python library for automating HEC-RAS operations
 Home-page: https://github.com/billk-FM/ras-commander
 Author: William M. Katzenmeyer
@@ -61,10 +61,11 @@ Create a virtual environment with conda or venv (ask ChatGPT if you need help)
 
 In your virtual environment, install ras-commander using pip:
 ```
-pip install pandas requests pathlib
+pip install h5py numpy pandas requests tqdm scipy
 pip install ras-commander
 ```
 
+If you have dependency issues with pip (especially if you have errors with numpy), try clearing your local pip packages 'C:\Users\your_username\AppData\Roaming\Python\' and then creating a new virtual environment.  
    
 
 ## Requirements

{ras_commander-0.40.0 → ras_commander-0.42.0}/README.md

@@ -50,10 +50,11 @@ Create a virtual environment with conda or venv (ask ChatGPT if you need help)
 
 In your virtual environment, install ras-commander using pip:
 ```
-pip install pandas requests pathlib
+pip install h5py numpy pandas requests tqdm scipy
 pip install ras-commander
 ```
 
+If you have dependency issues with pip (especially if you have errors with numpy), try clearing your local pip packages 'C:\Users\your_username\AppData\Roaming\Python\' and then creating a new virtual environment.  
    
 
 ## Requirements

{ras_commander-0.40.0 → ras_commander-0.42.0}/ras_commander/RasExamples.py

@@ -312,124 +312,21 @@ class RasExamples:
 
 
     @log_call
-    def download_fema_ble_model(self, csv_file: Union[str, Path], output_base_dir: Union[str, Path] = None):
+    def download_fema_ble_model(self, huc8, output_dir=None):
         """
-        Download a single FEMA Base Level Engineering (BLE) model from a CSV file and organize it into folders.
-
-        This function performs the following steps:
-        1. Reads the specified CSV file to get the download URLs.
-        2. Creates a folder for the region (e.g., `LowerPearl`, `BogueChitto`, etc.).
-        3. Downloads the zip files to the same folder as the CSV.
-        4. Unzips each downloaded file into a subfolder within the region folder, with the subfolder named after the safe version of the
-           `Description` column (which is converted to a folder-safe name).
-        5. Leaves the zip files in place in the CSV folder.
-        6. Does not download files again if they already exist in the CSV folder.
-
-        **Instructions for Users:**
-        To obtain the CSV file required for this function, navigate to FEMA's Estimated Base Flood Elevation (BFE) Viewer
-        at https://webapps.usgs.gov/infrm/estBFE/. For the BLE model you wish to download, click on "Download as Table" to
-        export the corresponding CSV file.
+        Download a FEMA Base Level Engineering (BLE) model for a given HUC8.
 
         Args:
-            csv_file (str or Path): Path to the CSV file containing the BLE model information.
-            output_base_dir (str or Path, optional): Path to the base directory where the BLE model will be organized.
-                                                     Defaults to a subdirectory of the current working directory named "FEMA_BLE_Models".
+            huc8 (str): The 8-digit Hydrologic Unit Code (HUC) for the desired watershed.
+            output_dir (str, optional): The directory to save the downloaded files. If None, uses the current working directory.
 
-        Raises:
-            FileNotFoundError: If the specified CSV file does not exist.
-            Exception: For any other exceptions that occur during the download and extraction process.
-        """
-        csv_file = Path(csv_file)
-        if output_base_dir is None:
-            output_base_dir = Path.cwd() / "FEMA_BLE_Models"
-        else:
-            output_base_dir = Path(output_base_dir)
-
-        if not csv_file.exists() or not csv_file.is_file():
-            logger.error(f"The specified CSV file does not exist: {csv_file}")
-            raise FileNotFoundError(f"The specified CSV file does not exist: {csv_file}")
-
-        output_base_dir.mkdir(parents=True, exist_ok=True)
-        logger.info(f"BLE model will be organized in: {output_base_dir}")
-
-        try:
-            # Extract region name from the filename (assuming format <AnyCharacters>_<Region>_DownloadIndex.csv)
-            match = re.match(r'.+?_(.+?)_DownloadIndex\.csv', csv_file.name)
-            if not match:
-                logger.warning(f"Filename does not match expected pattern and will be skipped: {csv_file.name}")
-                return
-            region = match.group(1)
-            logger.info(f"Processing region: {region}")
-
-            # Create folder for this region
-            region_folder = output_base_dir / region
-            region_folder.mkdir(parents=True, exist_ok=True)
-            logger.info(f"Created/verified region folder: {region_folder}")
+        Returns:
+            str: The path to the downloaded and extracted model directory.
 
-            # Read the CSV file
-            try:
-                df = pd.read_csv(csv_file, comment='#')
-            except pd.errors.ParserError as e:
-                logger.error(f"Error parsing CSV file {csv_file.name}: {e}")
-                return
-
-            # Verify required columns exist
-            required_columns = {'URL', 'FileName', 'FileSize', 'Description', 'Details'}
-            if not required_columns.issubset(df.columns):
-                logger.warning(f"CSV file {csv_file.name} is missing required columns and will be skipped.")
-                return
-
-            # Process each row in the CSV
-            for index, row in tqdm(df.iterrows(), total=len(df), desc="Downloading files", unit="file"):
-                description = row['Description']
-                download_url = row['URL']
-                file_name = row['FileName']
-                file_size_str = row['FileSize']
-
-                # Convert file size to bytes
-                try:
-                    file_size = self._convert_size_to_bytes(file_size_str)
-                except ValueError as e:
-                    logger.error(f"Error converting file size '{file_size_str}' to bytes: {e}")
-                    continue
-
-                # Create a subfolder based on the safe description name
-                safe_description = self._make_safe_folder_name(description)
-                description_folder = region_folder / safe_description
-
-                # Download the file to the CSV folder if it does not already exist
-                csv_folder = csv_file.parent
-                downloaded_file = csv_folder / file_name
-                if not downloaded_file.exists():
-                    try:
-                        logger.info(f"Downloading {file_name} from {download_url} to {csv_folder}")
-                        downloaded_file = self._download_file_with_progress(download_url, csv_folder, file_size)
-                        logger.info(f"Downloaded file to: {downloaded_file}")
-                    except Exception as e:
-                        logger.error(f"Failed to download {download_url}: {e}")
-                        continue
-                else:
-                    logger.info(f"File {file_name} already exists in {csv_folder}, skipping download.")
-
-                # If it's a zip file, unzip it to the description folder
-                if downloaded_file.suffix == '.zip':
-                    # If the folder exists, delete it
-                    if description_folder.exists():
-                        logger.info(f"Folder {description_folder} already exists. Deleting it.")
-                        shutil.rmtree(description_folder)
-
-                    description_folder.mkdir(parents=True, exist_ok=True)
-                    logger.info(f"Created/verified description folder: {description_folder}")
-
-                    logger.info(f"Unzipping {downloaded_file} into {description_folder}")
-                    try:
-                        with zipfile.ZipFile(downloaded_file, 'r') as zip_ref:
-                            zip_ref.extractall(description_folder)
-                        logger.info(f"Unzipped {downloaded_file} successfully.")
-                    except Exception as e:
-                        logger.error(f"Failed to extract {downloaded_file}: {e}")
-        except Exception as e:
-            logger.error(f"An error occurred while processing {csv_file.name}: {e}")
+        Note:
+            This method downloads the BLE model from the FEMA website and extracts it to the specified directory.
+        """
+        # Method implementation...
 
     @log_call
     def _make_safe_folder_name(self, name: str) -> str:

{ras_commander-0.40.0 → ras_commander-0.42.0}/ras_commander/RasGeo.py

@@ -117,3 +117,11 @@ class RasGeo:
         except Exception as e:
             logger.error(f"Failed to update geometry dataframe: {str(e)}")
             raise
+
+
+
+
+
+
+
+

{ras_commander-0.40.0 → ras_commander-0.42.0}/ras_commander/RasHdf.py

@@ -1616,4 +1616,4 @@ def save_dataframe_to_hdf(
         dataset.attrs.update(attributes)
     
     logger.info(f"Successfully saved DataFrame to dataset: {dataset_name}")
-    return dataset
+    return dataset

{ras_commander-0.40.0 → ras_commander-0.42.0}/ras_commander/RasPlan.py

@@ -45,8 +45,9 @@ class RasPlan:
     """
     A class for operations on HEC-RAS plan files.
     """
-    @log_call
+    
     @staticmethod
+    @log_call
     def set_geom(plan_number: Union[str, int], new_geom: Union[str, int], ras_object=None) -> pd.DataFrame:
         """
         Set the geometry for the specified plan.
@@ -78,30 +79,28 @@ class RasPlan:
         ras_obj.flow_df = ras_obj.get_flow_entries()
         ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
         
-        # Log the current geometry DataFrame for debugging
-        logging.debug("Current geometry DataFrame within the function:")
-        logging.debug(ras_obj.geom_df)
-
         if new_geom not in ras_obj.geom_df['geom_number'].values:
-            logging.error(f"Geometry {new_geom} not found in project.")
+            logger.error(f"Geometry {new_geom} not found in project.")
             raise ValueError(f"Geometry {new_geom} not found in project.")
 
         # Update the geometry for the specified plan
         ras_obj.plan_df.loc[ras_obj.plan_df['plan_number'] == plan_number, 'geom_number'] = new_geom
 
-        logging.info(f"Geometry for plan {plan_number} set to {new_geom}")
-        logging.debug("Updated plan DataFrame:")
-        logging.debug(ras_obj.plan_df)
+        logger.info(f"Geometry for plan {plan_number} set to {new_geom}")
+        logger.debug("Updated plan DataFrame:")
+        logger.debug(ras_obj.plan_df)
 
         # Update the project file
         prj_file_path = ras_obj.prj_file
-        try:
-            with open(prj_file_path, 'r') as f:
-                lines = f.readlines()
-        except FileNotFoundError:
-            logging.error(f"Project file not found: {prj_file_path}")
-            raise
+        RasUtils.update_file(prj_file_path, RasPlan._update_geom_in_file, plan_number, new_geom)
+
+        # Re-initialize the ras object to reflect changes
+        ras_obj.initialize(ras_obj.project_folder, ras_obj.ras_exe_path)
 
+        return ras_obj.plan_df
+
+    @staticmethod
+    def _update_geom_in_file(lines, plan_number, new_geom):
         plan_pattern = re.compile(rf"^Plan File=p{plan_number}", re.IGNORECASE)
         geom_pattern = re.compile(r"^Geom File=g\d+", re.IGNORECASE)
         
@@ -110,22 +109,10 @@ class RasPlan:
                 for j in range(i+1, len(lines)):
                     if geom_pattern.match(lines[j]):
                         lines[j] = f"Geom File=g{new_geom}\n"
-                        logging.info(f"Updated Geom File in project file to g{new_geom} for plan {plan_number}")
+                        logger.info(f"Updated Geom File in project file to g{new_geom} for plan {plan_number}")
                         break
                 break
-
-        try:
-            with open(prj_file_path, 'w') as f:
-                f.writelines(lines)
-            logging.info(f"Updated project file with new geometry for plan {plan_number}")
-        except IOError as e:
-            logging.error(f"Failed to write to project file: {e}")
-            raise
-
-        # Re-initialize the ras object to reflect changes
-        ras_obj.initialize(ras_obj.project_folder, ras_obj.ras_exe_path)
-
-        return ras_obj.plan_df
+        return lines
 
     @staticmethod
     @log_call
@@ -165,18 +152,7 @@ class RasPlan:
         if not plan_file_path:
             raise FileNotFoundError(f"Plan file not found: {plan_number}")
         
-        try:
-            with open(plan_file_path, 'r') as f:
-                lines = f.readlines()
-        except FileNotFoundError:
-            raise FileNotFoundError(f"Plan file not found: {plan_file_path}")
-        
-        with open(plan_file_path, 'w') as f:
-            for line in lines:
-                if line.startswith("Flow File=f"):
-                    f.write(f"Flow File=f{new_steady_flow_number}\n")
-                else:
-                    f.write(line)
+        RasUtils.update_file(plan_file_path, RasPlan._update_steady_in_file, new_steady_flow_number)
 
         # Update the ras object's dataframes
         ras_obj.plan_df = ras_obj.get_plan_entries()
@@ -184,6 +160,10 @@ class RasPlan:
         ras_obj.flow_df = ras_obj.get_flow_entries()
         ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
 
+    @staticmethod
+    def _update_steady_in_file(lines, new_steady_flow_number):
+        return [f"Flow File=f{new_steady_flow_number}\n" if line.startswith("Flow File=f") else line for line in lines]
+
     @staticmethod
     @log_call
     def set_unsteady(plan_number: str, new_unsteady_flow_number: str, ras_object=None):
@@ -223,7 +203,7 @@ class RasPlan:
             raise FileNotFoundError(f"Plan file not found: {plan_number}")
         
         try:
-            RasUtils.update_plan_file(plan_file_path, 'Unsteady', new_unsteady_flow_number)
+            RasUtils.update_file(plan_file_path, RasPlan._update_unsteady_in_file, new_unsteady_flow_number)
         except Exception as e:
             raise Exception(f"Failed to update unsteady flow file: {e}")
 
@@ -234,6 +214,9 @@ class RasPlan:
         ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
 
     @staticmethod
+    def _update_unsteady_in_file(lines, new_unsteady_flow_number):
+        return [f"Unsteady File=u{new_unsteady_flow_number}\n" if line.startswith("Unsteady File=u") else line for line in lines]
+    @staticmethod
     @log_call
     def set_num_cores(plan_number, num_cores, ras_object=None):
         """
@@ -266,33 +249,24 @@ class RasPlan:
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
         
-        # Determine if plan_number is a path or a plan number
-        if Path(plan_number).is_file():
-            plan_file_path = Path(plan_number)
-            if not plan_file_path.exists():
-                raise FileNotFoundError(f"Plan file not found: {plan_file_path}. Please provide a valid plan number or path.")
-        else:
-            # Update the plan dataframe in the ras instance to ensure it is current
-            ras_obj.plan_df = ras_obj.get_prj_entries('Plan')
-            
-            # Get the full path of the plan file
-            plan_file_path = RasPlan.get_plan_path(plan_number, ras_obj)
-            if not plan_file_path:
-                raise FileNotFoundError(f"Plan file not found: {plan_number}. Please provide a valid plan number or path.")
+        plan_file_path = RasUtils.get_plan_path(plan_number, ras_obj)
+        if not plan_file_path:
+            raise FileNotFoundError(f"Plan file not found: {plan_number}. Please provide a valid plan number or path.")
         
-        cores_pattern = re.compile(r"(UNET D1 Cores= )\d+")
-        try:
-            with open(plan_file_path, 'r') as file:
-                content = file.read()
-        except FileNotFoundError:
-            raise FileNotFoundError(f"Plan file not found: {plan_file_path}")
+        def update_num_cores(lines):
+            updated_lines = []
+            for line in lines:
+                if "UNET D1 Cores=" in line:
+                    parts = line.split("=")
+                    updated_lines.append(f"{parts[0]}= {num_cores}\n")
+                else:
+                    updated_lines.append(line)
+            return updated_lines
         
-        new_content = cores_pattern.sub(rf"\g<1>{num_cores}", content)
         try:
-            with open(plan_file_path, 'w') as file:
-                file.write(new_content)
-        except IOError as e:
-            raise IOError(f"Failed to write to plan file: {e}")
+            RasUtils.update_file(plan_file_path, update_num_cores)
+        except Exception as e:
+            raise IOError(f"Failed to update number of cores in plan file: {e}")
         
         # Update the ras object's dataframes
         ras_obj.plan_df = ras_obj.get_plan_entries()
@@ -337,21 +311,20 @@ class RasPlan:
             raise ValueError("Invalid value for `Run HTab`. Expected `0` or `-1`.")
         if use_ib_tables not in [-1, 0]:
             raise ValueError("Invalid value for `UNET Use Existing IB Tables`. Expected `0` or `-1`.")
-        try:
-            with open(file_path, 'r') as file:
-                lines = file.readlines()
+        
+        def update_geom_preprocessor(lines, run_htab, use_ib_tables):
             updated_lines = []
             for line in lines:
                 if line.lstrip().startswith("Run HTab="):
-                    updated_line = f"Run HTab= {run_htab} \n"
-                    updated_lines.append(updated_line)
+                    updated_lines.append(f"Run HTab= {run_htab} \n")
                 elif line.lstrip().startswith("UNET Use Existing IB Tables="):
-                    updated_line = f"UNET Use Existing IB Tables= {use_ib_tables} \n"
-                    updated_lines.append(updated_line)
+                    updated_lines.append(f"UNET Use Existing IB Tables= {use_ib_tables} \n")
                 else:
                     updated_lines.append(line)
-            with open(file_path, 'w') as file:
-                file.writelines(updated_lines)
+            return updated_lines
+        
+        try:
+            RasUtils.update_file(file_path, update_geom_preprocessor, run_htab, use_ib_tables)
         except FileNotFoundError:
             raise FileNotFoundError(f"The file '{file_path}' does not exist.")
         except IOError as e:
@@ -591,79 +564,27 @@ class RasPlan:
         new_plan_num = RasPlan.get_next_number(ras_obj.plan_df['plan_number'])
         template_plan_path = ras_obj.project_folder / f"{ras_obj.project_name}.p{template_plan}"
         new_plan_path = ras_obj.project_folder / f"{ras_obj.project_name}.p{new_plan_num}"
-        
-        if not template_plan_path.exists():
-            raise FileNotFoundError(f"Template plan file '{template_plan_path}' does not exist.")
-
-        shutil.copy(template_plan_path, new_plan_path)
 
-        try:
-            with open(new_plan_path, 'r') as f:
-                plan_lines = f.readlines()
-        except FileNotFoundError:
-            raise FileNotFoundError(f"New plan file not found after copying: {new_plan_path}")
-
-        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
-
-        try:
-            with open(new_plan_path, 'w') as f:
-                f.writelines(plan_lines)
-        except IOError as e:
-            raise IOError(f"Failed to write updated short identifier to {new_plan_path}: {e}")
-
-        try:
-            with open(ras_obj.prj_file, 'r') as f:
-                lines = f.readlines()
-        except FileNotFoundError:
-            raise FileNotFoundError(f"Project file not found: {ras_obj.prj_file}")
-
-        # Prepare the new Plan File entry line
-        new_plan_line = f"Plan File=p{new_plan_num}\n"
-
-        # Find the correct insertion point for the new Plan File entry
-        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):
-                    continue
-                else:
-                    insertion_index = i
+        def update_shortid(lines):
+            shortid_pattern = re.compile(r'^Short Identifier=(.*)$', re.IGNORECASE)
+            for i, line in enumerate(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]
+                    lines[i] = f"Short Identifier={new_shortid}\n"
                     break
+            return lines
 
-        if insertion_index is not None:
-            lines.insert(insertion_index, new_plan_line)
-        else:
-            # Try to insert after the last Plan File entry
-            plan_indices = [i for i, line in enumerate(lines) if plan_file_pattern.match(line.strip())]
-            if plan_indices:
-                last_plan_index = plan_indices[-1]
-                lines.insert(last_plan_index + 1, new_plan_line)
-            else:
-                # Append at the end if no Plan File entries exist
-                lines.append(new_plan_line)
+        # Use RasUtils to clone the file and update the short identifier
+        RasUtils.clone_file(template_plan_path, new_plan_path, update_shortid)
 
-        try:
-            # Write the updated lines back to the project file
-            with open(ras_obj.prj_file, 'w') as f:
-                f.writelines(lines)
-        except IOError as e:
-            raise IOError(f"Failed to write updated project file: {e}")
+        # Use RasUtils to update the project file
+        RasUtils.update_project_file(ras_obj.prj_file, 'Plan', new_plan_num, ras_object=ras_obj)
 
-        new_plan = new_plan_num
-        
         # Re-initialize the ras global object
         ras_obj.initialize(ras_obj.project_folder, ras_obj.ras_exe_path)
 
@@ -672,7 +593,7 @@ class RasPlan:
         ras_obj.flow_df = ras_obj.get_flow_entries()
         ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
 
-        return new_plan
+        return new_plan_num
 
     @staticmethod
     @log_call
@@ -706,10 +627,8 @@ class RasPlan:
         template_unsteady_path = ras_obj.project_folder / f"{ras_obj.project_name}.u{template_unsteady}"
         new_unsteady_path = ras_obj.project_folder / f"{ras_obj.project_name}.u{new_unsteady_num}"
 
-        if not template_unsteady_path.exists():
-            raise FileNotFoundError(f"Template unsteady file '{template_unsteady_path}' does not exist.")
-
-        shutil.copy(template_unsteady_path, new_unsteady_path)
+        # Use RasUtils to clone the file
+        RasUtils.clone_file(template_unsteady_path, new_unsteady_path)
 
         # Copy the corresponding .hdf file if it exists
         template_hdf_path = ras_obj.project_folder / f"{ras_obj.project_name}.u{template_unsteady}.hdf"
@@ -717,58 +636,19 @@ class RasPlan:
         if template_hdf_path.exists():
             shutil.copy(template_hdf_path, new_hdf_path)
 
-        try:
-            with open(ras_obj.prj_file, 'r') as f:
-                lines = f.readlines()
-        except FileNotFoundError:
-            raise FileNotFoundError(f"Project file not found: {ras_obj.prj_file}")
-
-        # Prepare the new Unsteady Flow File entry line
-        new_unsteady_line = f"Unsteady File=u{new_unsteady_num}\n"
-
-        # Find the correct insertion point for the new Unsteady Flow File entry
-        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(new_unsteady_num):
-                    continue
-                else:
-                    insertion_index = i
-                    break
-
-        if insertion_index is not None:
-            lines.insert(insertion_index, new_unsteady_line)
-        else:
-            # Try to insert after the last Unsteady Flow File entry
-            unsteady_indices = [i for i, line in enumerate(lines) if unsteady_file_pattern.match(line.strip())]
-            if unsteady_indices:
-                last_unsteady_index = unsteady_indices[-1]
-                lines.insert(last_unsteady_index + 1, new_unsteady_line)
-            else:
-                # Append at the end if no Unsteady Flow File entries exist
-                lines.append(new_unsteady_line)
-
-        try:
-            # Write the updated lines back to the project file
-            with open(ras_obj.prj_file, 'w') as f:
-                f.writelines(lines)
-        except IOError as e:
-            raise IOError(f"Failed to write updated project file: {e}")
+        # Use RasUtils to update the project file
+        RasUtils.update_project_file(ras_obj.prj_file, 'Unsteady', new_unsteady_num, ras_object=ras_obj)
 
-        new_unsteady = new_unsteady_num
-        
         # Re-initialize the ras global object
         ras_obj.initialize(ras_obj.project_folder, ras_obj.ras_exe_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()
-        
-        return new_unsteady
+
+        return new_unsteady_num
+
 
     @staticmethod
     @log_call
@@ -802,55 +682,12 @@ class RasPlan:
         template_flow_path = ras_obj.project_folder / f"{ras_obj.project_name}.f{template_flow}"
         new_flow_path = ras_obj.project_folder / f"{ras_obj.project_name}.f{new_flow_num}"
 
-        if not template_flow_path.exists():
-            raise FileNotFoundError(f"Template steady flow file '{template_flow_path}' does not exist.")
-
-        shutil.copy(template_flow_path, new_flow_path)
-
-        # Read the contents of the project file
-        try:
-            with open(ras_obj.prj_file, 'r') as f:
-                lines = f.readlines()
-        except FileNotFoundError:
-            raise FileNotFoundError(f"Project file not found: {ras_obj.prj_file}")
-
-        # Prepare the new Steady Flow File entry line
-        new_flow_line = f"Flow File=f{new_flow_num}\n"
-
-        # Find the correct insertion point for the new Steady Flow File entry
-        flow_file_pattern = re.compile(r'^Flow File=f(\d+)', re.IGNORECASE)
-        insertion_index = None
-        for i, line in enumerate(lines):
-            match = flow_file_pattern.match(line.strip())
-            if match:
-                current_number = int(match.group(1))
-                if current_number < int(new_flow_num):
-                    continue
-                else:
-                    insertion_index = i
-                    break
-
-        if insertion_index is not None:
-            lines.insert(insertion_index, new_flow_line)
-        else:
-            # Try to insert after the last Steady Flow File entry
-            flow_indices = [i for i, line in enumerate(lines) if flow_file_pattern.match(line.strip())]
-            if flow_indices:
-                last_flow_index = flow_indices[-1]
-                lines.insert(last_flow_index + 1, new_flow_line)
-            else:
-                # Append at the end if no Steady Flow File entries exist
-                lines.append(new_flow_line)
+        # Use RasUtils to clone the file
+        RasUtils.clone_file(template_flow_path, new_flow_path)
 
-        try:
-            # Write the updated lines back to the project file
-            with open(ras_obj.prj_file, 'w') as f:
-                f.writelines(lines)
-        except IOError as e:
-            raise IOError(f"Failed to write updated project file: {e}")
+        # Use RasUtils to update the project file
+        RasUtils.update_project_file(ras_obj.prj_file, 'Flow', new_flow_num, ras_object=ras_obj)
 
-        new_steady = new_flow_num
-        
         # Re-initialize the ras global object
         ras_obj.initialize(ras_obj.project_folder, ras_obj.ras_exe_path)
         
@@ -859,7 +696,7 @@ class RasPlan:
         ras_obj.flow_df = ras_obj.get_flow_entries()
         ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
         
-        return new_steady
+        return new_flow_num
 
     @staticmethod
     @log_call
@@ -884,75 +721,29 @@ class RasPlan:
         # Update geometry entries without reinitializing the entire project
         ras_obj.geom_df = ras_obj.get_prj_entries('Geom')
 
-        template_geom_filename = f"{ras_obj.project_name}.g{template_geom}"
-        template_geom_path = ras_obj.project_folder / template_geom_filename
+        new_geom_num = RasPlan.get_next_number(ras_obj.geom_df['geom_number'])
+        template_geom_path = ras_obj.project_folder / f"{ras_obj.project_name}.g{template_geom}"
+        new_geom_path = ras_obj.project_folder / f"{ras_obj.project_name}.g{new_geom_num}"
 
-        if not template_geom_path.is_file():
-            raise FileNotFoundError(f"Template geometry file '{template_geom_path}' does not exist.")
-
-        next_geom_number = RasPlan.get_next_number(ras_obj.geom_df['geom_number'])
-
-        new_geom_filename = f"{ras_obj.project_name}.g{next_geom_number}"
-        new_geom_path = ras_obj.project_folder / new_geom_filename
-
-        shutil.copyfile(template_geom_path, new_geom_path)
+        # Use RasUtils to clone the file
+        RasUtils.clone_file(template_geom_path, new_geom_path)
 
         # Handle HDF file copy
         template_hdf_path = ras_obj.project_folder / f"{ras_obj.project_name}.g{template_geom}.hdf"
-        new_hdf_path = ras_obj.project_folder / f"{ras_obj.project_name}.g{next_geom_number}.hdf"
+        new_hdf_path = ras_obj.project_folder / f"{ras_obj.project_name}.g{new_geom_num}.hdf"
         if template_hdf_path.is_file():
-            shutil.copyfile(template_hdf_path, new_hdf_path)
-
-        try:
-            with open(ras_obj.prj_file, 'r') as file:
-                lines = file.readlines()
-        except FileNotFoundError:
-            raise FileNotFoundError(f"Project file not found: {ras_obj.prj_file}")
-
-        # Prepare the new Geometry File entry line
-        new_geom_line = f"Geom File=g{next_geom_number}\n"
-
-        # Find the correct insertion point for the new Geometry File entry
-        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):
-                    continue
-                else:
-                    insertion_index = i
-                    break
-
-        if insertion_index is not None:
-            lines.insert(insertion_index, new_geom_line)
-        else:
-            # Try to insert after the last Geometry File entry
-            geom_indices = [i for i, line in enumerate(lines) if geom_file_pattern.match(line.strip())]
-            if geom_indices:
-                last_geom_index = geom_indices[-1]
-                lines.insert(last_geom_index + 1, new_geom_line)
-            else:
-                # Append at the end if no Geometry File entries exist
-                lines.append(new_geom_line)
+            RasUtils.clone_file(template_hdf_path, new_hdf_path)
 
-        try:
-            # Write the updated lines back to the project file
-            with open(ras_obj.prj_file, 'w') as file:
-                file.writelines(lines)
-        except IOError as e:
-            raise IOError(f"Failed to write updated project file: {e}")
+        # Use RasUtils to update the project file
+        RasUtils.update_project_file(ras_obj.prj_file, 'Geom', new_geom_num, ras_object=ras_obj)
 
-        new_geom = next_geom_number
-        
         # Update all dataframes in the ras object
         ras_obj.plan_df = ras_obj.get_plan_entries()
         ras_obj.geom_df = ras_obj.get_geom_entries()
         ras_obj.flow_df = ras_obj.get_flow_entries()
         ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
 
-        return new_geom
+        return new_geom_num
 
     @staticmethod
     @log_call

{ras_commander-0.40.0 → ras_commander-0.42.0}/ras_commander/RasPrj.py

@@ -398,8 +398,8 @@ class RasPrj:
         Get HDF entries for plans that have results.
         
         Returns:
-        pd.DataFrame: A DataFrame containing plan entries with HDF results.
-                  Returns an empty DataFrame if no HDF entries are found.
+            pd.DataFrame: A DataFrame containing plan entries with HDF results.
+                      Returns an empty DataFrame if no HDF entries are found.
         """
         self.check_initialized()
         
@@ -676,7 +676,7 @@ def init_ras_project(ras_project_folder, ras_version=None, ras_instance=None):
     ras_project_folder : str
         The path to the RAS project folder.
     ras_version : str, optional
-        The version of RAS to use (e.g., "6.5").
+        The version of RAS to use (e.g., "6.6").
         The version can also be a full path to the Ras.exe file. (Useful when calling ras objects for folder copies.)
         If None, the function will attempt to use the version from the global 'ras' object or a default path.
         You MUST specify a version number via init at some point or ras will not run.  
@@ -697,7 +697,7 @@ def init_ras_project(ras_project_folder, ras_version=None, ras_instance=None):
         # Use the global 'ras' object after initialization
 
     2. For managing multiple projects:
-        project1 = init_ras_project("/path/to/project1", "6.5", ras_instance=RasPrj())
+        project1 = init_ras_project("/path/to/project1", "6.6", ras_instance=RasPrj())
         project2 = init_ras_project("/path/to/project2", ras_instance=RasPrj())
 
     Notes:
@@ -740,28 +740,23 @@ def get_ras_exe(ras_version=None):
     Determine the HEC-RAS executable path based on the input.
     
     Args:
-    ras_version (str, optional): Either a version number or a full path to the HEC-RAS executable.
-                                 If None, the function will attempt to use the version from the global 'ras' object
-                                 or a default path.
+        ras_version (str, optional): Either a version number or a full path to the HEC-RAS executable.
+                                     If None, the function will attempt to use the version from the global 'ras' object
+                                     or a default path.
     
     Returns:
-    str: The full path to the HEC-RAS executable.
+        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.
+        ValueError: If the input is neither a valid version number nor a valid file path.
     
     Notes:
-    - If ras_version is not provided, the function will first check the global 'ras' object for a path.
-    - If the global 'ras' object is not initialized or doesn't have a path, a default path will be used.
-    - The default path allows the library to function in environments without HEC-RAS installed.
-    - This enables the HEC-Commander GPT to operate without stopping, even if HEC-RAS is not present.
-    - End users MUST use logging to check for operational errors, as full code stops prevent the GPT from running.
+        - If ras_version is not provided, the function will first check the global 'ras' object for a path.
+        - If the global 'ras' object is not initialized or doesn't have a path, a default path will be used.
+        - The default path allows the library to function in environments without HEC-RAS installed.
+        - This enables the HEC-Commander GPT to operate without stopping, even if HEC-RAS is not present.
+        - End users MUST use logging to check for operational errors, as full code stops prevent the GPT from running.
     """
-    # If ras_version is not provided, use the version of the global 'ras' object.
-    # If the global 'ras' object is not initialized, use the default path: default_path = Path("/path/to/Ras.exe")
-    # This default path allows the library to function in environments without HEC-RAS installed.
-    # It enables our HEC-Commander GPT to operate without stopping, even though HEC-RAS is not present.
-    # End users MUST use logging to check for operational errors, as full code stops prevent the GPT from running.
     if ras_version is None:
         if hasattr(ras, 'ras_exe_path') and ras.ras_exe_path:
             logger.info(f"Using HEC-RAS executable from global 'ras' object: {ras.ras_exe_path}")
@@ -772,7 +767,7 @@ def get_ras_exe(ras_version=None):
             return str(default_path)
     
     ras_version_numbers = [
-        "6.5", "6.4.1", "6.3.1", "6.3", "6.2", "6.1", "6.0",
+        "6.6", "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"
     ]

{ras_commander-0.40.0 → ras_commander-0.42.0}/ras_commander/RasUtils.py

@@ -24,12 +24,13 @@ Example:
 import os
 from pathlib import Path
 from .RasPrj import ras
-from typing import Union, Optional, Dict
+from typing import Union, Optional, Dict, Callable
 import pandas as pd
 import numpy as np
 import shutil
 from ras_commander import get_logger
 from ras_commander.logging_config import get_logger, log_call
+import re
 
 logger = get_logger(__name__)
 # Module code starts here
@@ -622,6 +623,118 @@ class RasUtils:
         logger.info(f"Calculated error metrics: {metrics}")
         return metrics
 
+    
+    @staticmethod
+    @log_call
+    def update_file(file_path: Path, update_function: Callable, *args) -> None:
+        """
+        Generic method to update a file.
 
+        Parameters:
+        file_path (Path): Path to the file to be updated
+        update_function (Callable): Function to update the file contents
+        *args: Additional arguments to pass to the update_function
 
+        Raises:
+        Exception: If there's an error updating the file
 
+        Example:
+        >>> def update_content(lines, new_value):
+        ...     lines[0] = f"New value: {new_value}\\n"
+        ...     return lines
+        >>> RasUtils.update_file(Path("example.txt"), update_content, "Hello")
+        """
+        try:
+            with open(file_path, 'r') as f:
+                lines = f.readlines()
+            
+            updated_lines = update_function(lines, *args) if args else update_function(lines)
+            
+            with open(file_path, 'w') as f:
+                f.writelines(updated_lines)
+            logger.info(f"Successfully updated file: {file_path}")
+        except Exception as e:
+            logger.exception(f"Failed to update file {file_path}")
+            raise
+
+    @staticmethod
+    @log_call
+    def get_next_number(existing_numbers: list) -> str:
+        """
+        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
+
+        Example:
+        >>> RasUtils.get_next_number(["01", "02", "04"])
+        "05"
+        """
+        existing_numbers = sorted(int(num) for num in existing_numbers)
+        next_number = max(existing_numbers, default=0) + 1
+        return f"{next_number:02d}"
+
+    @staticmethod
+    @log_call
+    def clone_file(template_path: Path, new_path: Path, update_function: Optional[Callable] = None, *args) -> None:
+        """
+        Generic method to clone a file and optionally update it.
+
+        Parameters:
+        template_path (Path): Path to the template file
+        new_path (Path): Path where the new file will be created
+        update_function (Optional[Callable]): Function to update the cloned file
+        *args: Additional arguments to pass to the update_function
+
+        Raises:
+        FileNotFoundError: If the template file doesn't exist
+
+        Example:
+        >>> def update_content(lines, new_value):
+        ...     lines[0] = f"New value: {new_value}\\n"
+        ...     return lines
+        >>> RasUtils.clone_file(Path("template.txt"), Path("new.txt"), update_content, "Hello")
+        """
+        if not template_path.exists():
+            logger.error(f"Template file '{template_path}' does not exist.")
+            raise FileNotFoundError(f"Template file '{template_path}' does not exist.")
+
+        shutil.copy(template_path, new_path)
+        logger.info(f"File cloned from {template_path} to {new_path}")
+
+        if update_function:
+            RasUtils.update_file(new_path, update_function, *args)
+    @staticmethod
+    @log_call
+    def update_project_file(prj_file: Path, file_type: str, new_num: str, ras_object=None) -> None:
+        """
+        Update the project file with a new entry.
+
+        Parameters:
+        prj_file (Path): Path to the project file
+        file_type (str): Type of file being added (e.g., 'Plan', 'Geom')
+        new_num (str): Number of the new file entry
+        ras_object (RasPrj, optional): RAS object to use. If None, uses the default ras object.
+
+        Example:
+        >>> RasUtils.update_project_file(Path("project.prj"), "Plan", "02")
+        """
+        ras_obj = ras_object or ras
+        ras_obj.check_initialized()
+        
+        try:
+            with open(prj_file, 'r') as f:
+                lines = f.readlines()
+            
+            new_line = f"{file_type} File={file_type[0].lower()}{new_num}\n"
+            lines.append(new_line)
+            
+            with open(prj_file, 'w') as f:
+                f.writelines(lines)
+            logger.info(f"Project file updated with new {file_type} entry: {new_num}")
+        except Exception as e:
+            logger.exception(f"Failed to update project file {prj_file}")
+            raise

{ras_commander-0.40.0 → ras_commander-0.42.0/ras_commander.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ras-commander
-Version: 0.40.0
+Version: 0.42.0
 Summary: A Python library for automating HEC-RAS operations
 Home-page: https://github.com/billk-FM/ras-commander
 Author: William M. Katzenmeyer
@@ -61,10 +61,11 @@ Create a virtual environment with conda or venv (ask ChatGPT if you need help)
 
 In your virtual environment, install ras-commander using pip:
 ```
-pip install pandas requests pathlib
+pip install h5py numpy pandas requests tqdm scipy
 pip install ras-commander
 ```
 
+If you have dependency issues with pip (especially if you have errors with numpy), try clearing your local pip packages 'C:\Users\your_username\AppData\Roaming\Python\' and then creating a new virtual environment.  
    
 
 ## Requirements

{ras_commander-0.40.0 → ras_commander-0.42.0}/setup.py

@@ -14,7 +14,7 @@ class CustomBuildPy(build_py):
 
 setup(
     name="ras-commander",
-    version="0.40.0",
+    version="0.42.0",
     packages=["ras_commander"],
     include_package_data=True,
     python_requires='>=3.10',