ras-commander 0.66.0__py3-none-any.whl → 0.68.0__py3-none-any.whl

ras_commander/Decorators.py

@@ -4,6 +4,7 @@ from typing import Union
 import logging
 import h5py
 import inspect
+import pandas as pd
 
 
 def log_call(func):
@@ -44,16 +45,23 @@ def standardize_input(file_type: str = 'plan_hdf'):
             sig = inspect.signature(func)
             param_names = list(sig.parameters.keys())
             
-            # If first parameter is 'hdf_file', skip path processing
+            # If first parameter is 'hdf_file', pass an h5py object
             if param_names and param_names[0] == 'hdf_file':
-                return func(*args, **kwargs)
+                if isinstance(args[0], h5py.File):
+                    return func(*args, **kwargs)
+                elif isinstance(args[0], (str, Path)):
+                    with h5py.File(args[0], 'r') as hdf:
+                        return func(hdf, *args[1:], **kwargs)
+                else:
+                    raise ValueError(f"Expected h5py.File or path, got {type(args[0])}")
                 
             # Handle both static method calls and regular function calls
             if args and isinstance(args[0], type):
                 # Static method call, remove the class argument
                 args = args[1:]
             
-            hdf_input = kwargs.pop('hdf_path', None) or kwargs.pop('hdf_input', None) or (args[0] if args else None)
+            # Get hdf_input from kwargs if provided with hdf_path key, or take first positional arg
+            hdf_input = kwargs.pop('hdf_path', None) if 'hdf_path' in kwargs else (args[0] if args else None)
             
             # Import ras here to ensure we get the most current instance
             from .RasPrj import ras as ras
@@ -64,80 +72,134 @@ def standardize_input(file_type: str = 'plan_hdf'):
             if hdf_input is None:
                 return func(*args, **kwargs)
 
-            # NEW: If input is already a Path and exists, use it directly regardless of file_type
-            if isinstance(hdf_input, Path) and hdf_input.is_file():
-                logger.info(f"Using existing HDF file: {hdf_input}")
-                new_args = (hdf_input,) + args[1:]
-                return func(*new_args, **kwargs)
-
             hdf_path = None
 
-            # If hdf_input is already an h5py.File object, use its filename
-            if isinstance(hdf_input, h5py.File):
-                hdf_path = Path(hdf_input.filename)
-            # Handle Path objects
-            elif isinstance(hdf_input, Path):
-                if hdf_input.is_file():
+            # Clean and normalize string inputs
+            if isinstance(hdf_input, str):
+                # Clean the string (remove extra whitespace, normalize path separators)
+                hdf_input = hdf_input.strip()
+                
+                # Check if it's a raw file path that exists
+                try:
+                    test_path = Path(hdf_input)
+                    if test_path.is_file():
+                        hdf_path = test_path
+                        logger.info(f"Using HDF file from direct string path: {hdf_path}")
+                except Exception as e:
+                    logger.debug(f"Error converting string to path: {str(e)}")
+
+            # If a valid path wasn't created from string processing, continue with normal flow
+            if hdf_path is None:
+                # If hdf_input is already a Path and exists, use it directly
+                if isinstance(hdf_input, Path) and hdf_input.is_file():
                     hdf_path = hdf_input
-            # Handle string inputs
-            elif isinstance(hdf_input, str):
-                # Check if it's a file path
-                if Path(hdf_input).is_file():
-                    hdf_path = Path(hdf_input)
-                # Check if it's a number (with or without 'p' prefix)
-                elif hdf_input.isdigit() or (len(hdf_input) > 1 and hdf_input[0] == 'p' and hdf_input[1:].isdigit()):
+                    logger.info(f"Using existing Path object HDF file: {hdf_path}")
+                # If hdf_input is an h5py.File object, use its filename
+                elif isinstance(hdf_input, h5py.File):
+                    hdf_path = Path(hdf_input.filename)
+                    logger.info(f"Using HDF file from h5py.File object: {hdf_path}")
+                # Handle Path objects that might not be verified yet
+                elif isinstance(hdf_input, Path):
+                    if hdf_input.is_file():
+                        hdf_path = hdf_input
+                        logger.info(f"Using verified Path object HDF file: {hdf_path}")
+                # Handle string inputs that are plan/geom numbers
+                elif isinstance(hdf_input, str) and (hdf_input.isdigit() or (len(hdf_input) > 1 and hdf_input[0] == 'p' and hdf_input[1:].isdigit())):
                     try:
                         ras_obj.check_initialized()
                     except Exception as e:
                         raise ValueError(f"RAS object is not initialized: {str(e)}")
                         
-                    # Extract the numeric part and convert to integer for comparison
                     number_str = hdf_input if hdf_input.isdigit() else hdf_input[1:]
                     number_int = int(number_str)
                     
                     if file_type == 'plan_hdf':
-                        # Convert plan_number column to integers for comparison
-                        plan_info = ras_obj.plan_df[ras_obj.plan_df['plan_number'].astype(int) == number_int]
-                        if not plan_info.empty:
-                            hdf_path = Path(plan_info.iloc[0]['HDF_Results_Path'])
+                        try:
+                            # Convert plan_number column to integers for comparison
+                            plan_info = ras_obj.plan_df[ras_obj.plan_df['plan_number'].astype(int) == number_int]
+                            if not plan_info.empty:
+                                # Make sure HDF_Results_Path is a string and not None
+                                hdf_path_str = plan_info.iloc[0]['HDF_Results_Path']
+                                if pd.notna(hdf_path_str):
+                                    hdf_path = Path(str(hdf_path_str))
+                        except Exception as e:
+                            logger.warning(f"Error retrieving plan HDF path: {str(e)}")
+
+
                     elif file_type == 'geom_hdf':
-                        # Convert geom_number column to integers for comparison
-                        geom_info = ras_obj.geom_df[ras_obj.geom_df['geom_number'].astype(int) == number_int]
-                        if not geom_info.empty:
-                            hdf_path = Path(geom_info.iloc[0]['HDF_Path'])
+                        try:
+                            # Convert geometry_number column to integers for comparison
+                            geom_info = ras_obj.plan_df[ras_obj.plan_df['geometry_number'].astype(int) == number_int]
+                            if not geom_info.empty:
+                                hdf_path_str = ras_obj.geom_df.iloc[0]['hdf_path'] 
+                                if pd.notna(hdf_path_str):
+                                    hdf_path = Path(str(hdf_path_str))
+                        except Exception as e:
+                            logger.warning(f"Error retrieving geometry HDF path: {str(e)}")
                     else:
                         raise ValueError(f"Invalid file type: {file_type}")
-            # Handle integer inputs (assuming they're plan or geom numbers)
-            elif isinstance(hdf_input, int):
-                try:
-                    ras_obj.check_initialized()
-                except Exception as e:
-                    raise ValueError(f"RAS object is not initialized: {str(e)}")
                     
-                number_int = hdf_input
+
+
                 
-                if file_type == 'plan_hdf':
-                    # Convert plan_number column to integers for comparison
-                    plan_info = ras_obj.plan_df[ras_obj.plan_df['plan_number'].astype(int) == number_int]
-                    if not plan_info.empty:
-                        hdf_path = Path(plan_info.iloc[0]['HDF_Results_Path'])
-                elif file_type == 'geom_hdf':
-                    # Convert geom_number column to integers for comparison
-                    geom_info = ras_obj.geom_df[ras_obj.geom_df['geom_number'].astype(int) == number_int]
-                    if not geom_info.empty:
-                        hdf_path = Path(geom_info.iloc[0]['HDF_Path'])
-                else:
-                    raise ValueError(f"Invalid file type: {file_type}")
+                # Handle integer inputs (assuming they're plan or geom numbers)
+                elif isinstance(hdf_input, int):
+                    try:
+                        ras_obj.check_initialized()
+                    except Exception as e:
+                        raise ValueError(f"RAS object is not initialized: {str(e)}")
+                        
+                    number_int = hdf_input
+                    
+                    if file_type == 'plan_hdf':
+                        try:
+                            # Convert plan_number column to integers for comparison
+                            plan_info = ras_obj.plan_df[ras_obj.plan_df['plan_number'].astype(int) == number_int]
+                            if not plan_info.empty:
+                                # Make sure HDF_Results_Path is a string and not None
+                                hdf_path_str = plan_info.iloc[0]['HDF_Results_Path']
+                                if pd.notna(hdf_path_str):
+                                    hdf_path = Path(str(hdf_path_str))
+                        except Exception as e:
+                            logger.warning(f"Error retrieving plan HDF path: {str(e)}")
+                    elif file_type == 'geom_hdf':
+                        try:
+                            # Convert geometry_number column to integers for comparison
+                            geom_info = ras_obj.plan_df[ras_obj.plan_df['geometry_number'].astype(int) == number_int]
+                            if not geom_info.empty:
+                                hdf_path_str = ras_obj.geom_df.iloc[0]['hdf_path'] 
+                                if pd.notna(hdf_path_str):
+                                    hdf_path = Path(str(hdf_path_str))
+                        except Exception as e:
+                            logger.warning(f"Error retrieving geometry HDF path: {str(e)}")
+                    else:
+                        raise ValueError(f"Invalid file type: {file_type}")
 
-            if hdf_path is None or not hdf_path.is_file():
+            # Final verification that the path exists
+            if hdf_path is None or not hdf_path.exists():
                 error_msg = f"HDF file not found: {hdf_input}"
                 logger.error(error_msg)
                 raise FileNotFoundError(error_msg)
-
-            logger.info(f"Using HDF file: {hdf_path}")
+                
+            logger.info(f"Final validated HDF file path: {hdf_path}")
+            
+            # Now try to validate the HDF file structure (but don't fail if validation fails)
+            try:
+                with h5py.File(hdf_path, 'r') as test_file:
+                    # Just open to verify it's a valid HDF5 file
+                    logger.debug(f"Successfully opened HDF file for validation: {hdf_path}")
+            except Exception as e:
+                logger.warning(f"Warning: Could not validate HDF file: {str(e)}")
+                # Continue anyway, let the function handle detailed validation
             
             # Pass all original arguments and keywords, replacing hdf_input with standardized hdf_path
-            new_args = (hdf_path,) + args[1:]
+            # If the original input was positional, replace the first argument
+            if args and 'hdf_path' not in kwargs:
+                new_args = (hdf_path,) + args[1:]
+            else:
+                new_args = args
+                kwargs['hdf_path'] = hdf_path
+                
             return func(*new_args, **kwargs)
 
         return wrapper

ras_commander/HdfPlan.py

@@ -11,25 +11,7 @@ The file has been forked and modified for use in RAS Commander.
 
 All of the methods in this class are static and are designed to be used without instantiation.
 
-List of Functions in HdfPlan:
-- get_simulation_start_time()
-- get_simulation_end_time()
-- get_unsteady_datetimes()
-- get_plan_info_attrs()
-- get_plan_parameters()
-- get_meteorology_precip_attrs()
-- get_geom_attrs()
-
-
-REVISIONS NEEDED: 
 
-Use get_ prefix for functions that return data.  
-Since we are extracting plan data, we should use get_plan_...
-BUT, we will never set results data, so we should use results_
-
-We need to shorten names where possible.
-
-List of Revised Functions in HdfPlan:
 - get_plan_start_time()
 - get_plan_end_time()
 - get_plan_timestamps_list()     
@@ -283,7 +265,7 @@ class HdfPlan:
         
     @staticmethod
     @log_call
-    @standardize_input(file_type='plan_hdf')
+    @standardize_input(file_type='geom_hdf')
     def get_geometry_information(hdf_path: Path) -> pd.DataFrame:
         """
         Get root level geometry attributes from the HDF plan file.

ras_commander/HdfResultsMesh.py

@@ -150,8 +150,8 @@ class HdfResultsMesh:
         Valid variables include:
             "Water Surface", "Face Velocity", "Cell Velocity X"...
         """
-        with h5py.File(hdf_path, 'r') as hdf_file:
-            return HdfResultsMesh._get_mesh_timeseries_output(hdf_file, mesh_name, var, truncate)
+        with h5py.File(hdf_path, 'r') as hdf_path:
+            return HdfResultsMesh._get_mesh_timeseries_output(hdf_path, mesh_name, var, truncate)
 
     @staticmethod
     @log_call
@@ -210,8 +210,8 @@ class HdfResultsMesh:
                 - Variable metadata
         """
         try:
-            with h5py.File(hdf_path, 'r') as hdf_file:
-                return HdfResultsMesh._get_mesh_cells_timeseries_output(hdf_file, mesh_names, var, truncate)
+            with h5py.File(hdf_path, 'r') as hdf_path:
+                return HdfResultsMesh._get_mesh_cells_timeseries_output(hdf_path, mesh_names, var, truncate)
         except Exception as e:
             logger.error(f"Error in get_mesh_cells_timeseries: {str(e)}")
             raise ValueError(f"Error processing timeseries output data: {e}")
@@ -219,7 +219,7 @@ class HdfResultsMesh:
     @staticmethod
     @log_call
     @standardize_input(file_type='plan_hdf')
-    def get_mesh_last_iter(hdf_path: Path) -> pd.DataFrame:
+    def get_mesh_last_iter(hdf_file: Path) -> pd.DataFrame:
         """
         Get last iteration count for each mesh cell.
 
@@ -229,7 +229,7 @@ class HdfResultsMesh:
         Returns:
             pd.DataFrame: DataFrame containing last iteration counts.
         """
-        return HdfResultsMesh.get_mesh_summary_output(hdf_path, "Cell Last Iteration")
+        return HdfResultsMesh.get_mesh_summary_output(hdf_file, "Cell Last Iteration")
 
 
     @staticmethod
@@ -394,7 +394,7 @@ class HdfResultsMesh:
 
 
     @staticmethod
-    def _get_mesh_cells_timeseries_output(hdf_file: h5py.File, 
+    def _get_mesh_cells_timeseries_output(hdf_path: h5py.File, 
                                          mesh_names: Optional[Union[str, List[str]]] = None,
                                          var: Optional[str] = None, 
                                          truncate: bool = False) -> Dict[str, xr.Dataset]:
@@ -402,7 +402,7 @@ class HdfResultsMesh:
         Get mesh cells timeseries output for specified meshes and variables.
         
         Args:
-            hdf_file (h5py.File): Open HDF file object.
+            hdf_path (h5py.File): Open HDF file object.
             mesh_names (Optional[Union[str, List[str]]]): Name(s) of the mesh(es). If None, processes all available meshes.
             var (Optional[str]): Name of the variable to retrieve. If None, retrieves all variables.
             truncate (bool): If True, truncates the output to remove trailing zeros.
@@ -431,11 +431,11 @@ class HdfResultsMesh:
         }
 
         try:
-            start_time = HdfBase.get_simulation_start_time(hdf_file)
-            time_stamps = HdfBase.get_unsteady_timestamps(hdf_file)
+            start_time = HdfBase.get_simulation_start_time(hdf_path)
+            time_stamps = HdfBase.get_unsteady_timestamps(hdf_path)
 
             if mesh_names is None:
-                mesh_names = HdfResultsMesh._get_available_meshes(hdf_file)
+                mesh_names = HdfResultsMesh._get_available_meshes(hdf_path)
             elif isinstance(mesh_names, str):
                 mesh_names = [mesh_names]
 
@@ -450,7 +450,7 @@ class HdfResultsMesh:
                 for variable in variables:
                     try:
                         path = HdfResultsMesh._get_mesh_timeseries_output_path(mesh_name, variable)
-                        dataset = hdf_file[path]
+                        dataset = hdf_path[path]
                         values = dataset[:]
                         units = dataset.attrs.get("Units", "").decode("utf-8")
 
@@ -495,12 +495,12 @@ class HdfResultsMesh:
 
 
     @staticmethod
-    def _get_mesh_timeseries_output(hdf_file: h5py.File, mesh_name: str, var: str, truncate: bool = True) -> xr.DataArray:
+    def _get_mesh_timeseries_output(hdf_path: h5py.File, mesh_name: str, var: str, truncate: bool = True) -> xr.DataArray:
         """
         Get timeseries output for a specific mesh and variable.
 
         Args:
-            hdf_file (h5py.File): Open HDF file object.
+            hdf_path (h5py.File): Open HDF file object.
             mesh_name (str): Name of the mesh.
             var (str): Variable name to retrieve.
             truncate (bool): Whether to truncate the output to remove trailing zeros (default True).
@@ -514,18 +514,18 @@ class HdfResultsMesh:
         try:
             path = HdfResultsMesh._get_mesh_timeseries_output_path(mesh_name, var)
             
-            if path not in hdf_file:
+            if path not in hdf_path:
                 raise ValueError(f"Path {path} not found in HDF file")
 
-            dataset = hdf_file[path]
+            dataset = hdf_path[path]
             values = dataset[:]
             units = dataset.attrs.get("Units", "").decode("utf-8")
             
             # Get start time and timesteps
-            start_time = HdfBase.get_simulation_start_time(hdf_file)
+            start_time = HdfBase.get_simulation_start_time(hdf_path)
             # Updated to use the new function name from HdfUtils
             timesteps = HdfUtils.convert_timesteps_to_datetimes(
-                np.array(hdf_file["Results/Unsteady/Output/Output Blocks/Base Output/Unsteady Time Series/Time"][:]),
+                np.array(hdf_path["Results/Unsteady/Output/Output Blocks/Base Output/Unsteady Time Series/Time"][:]),
                 start_time
             )
 
@@ -555,12 +555,12 @@ class HdfResultsMesh:
 
 
     @staticmethod
-    def _get_mesh_timeseries_output_values_units(hdf_file: h5py.File, mesh_name: str, var: str) -> Tuple[np.ndarray, str]:
+    def _get_mesh_timeseries_output_values_units(hdf_path: h5py.File, mesh_name: str, var: str) -> Tuple[np.ndarray, str]:
         """
         Get the mesh timeseries output values and units for a specific variable from the HDF file.
 
         Args:
-            hdf_file (h5py.File): Open HDF file object.
+            hdf_path (h5py.File): Open HDF file object.
             mesh_name (str): Name of the mesh.
             var (str): Variable name to retrieve.
 
@@ -568,7 +568,7 @@ class HdfResultsMesh:
             Tuple[np.ndarray, str]: A tuple containing the output values and units.
         """
         path = HdfResultsMesh._get_mesh_timeseries_output_path(mesh_name, var)
-        group = hdf_file[path]
+        group = hdf_path[path]
         values = group[:]
         units = group.attrs.get("Units")
         if units is not None:
@@ -577,17 +577,17 @@ class HdfResultsMesh:
 
 
     @staticmethod
-    def _get_available_meshes(hdf_file: h5py.File) -> List[str]:
+    def _get_available_meshes(hdf_path: h5py.File) -> List[str]:
         """
         Get the names of all available meshes in the HDF file.
 
         Args:
-            hdf_file (h5py.File): Open HDF file object.
+            hdf_path (h5py.File): Open HDF file object.
 
         Returns:
             List[str]: A list of mesh names.
         """
-        return HdfMesh.get_mesh_area_names(hdf_file)
+        return HdfMesh.get_mesh_area_names(hdf_path)
     
     
     @staticmethod
@@ -599,7 +599,7 @@ class HdfResultsMesh:
 
         Parameters
         ----------
-        hdf_file : h5py.File
+        hdf_path : h5py.File
             Open HDF file object.
         var : str
             The summary output variable to retrieve.
@@ -734,7 +734,7 @@ class HdfResultsMesh:
         Return the HDF group for a given mesh and summary output variable.
 
         Args:
-            hdf_file (h5py.File): Open HDF file object.
+            hdf_path (h5py.File): Open HDF file object.
             mesh_name (str): Name of the mesh.
             var (str): Name of the summary output variable.
 

ras_commander/RasPrj.py

@@ -175,6 +175,9 @@ class RasPrj:
             # Set paths for geometry and flow files
             self._set_file_paths()
             
+            # Make sure all plan paths are properly set
+            self._set_plan_paths()
+            
         except Exception as e:
             logger.error(f"Error loading project data: {e}")
             raise
@@ -220,6 +223,44 @@ class RasPrj:
             flow_path = self.project_folder / f"{self.project_name}.{prefix}{row['Flow File']}"
             self.plan_df.at[idx, 'Flow Path'] = str(flow_path)
 
+    def _set_plan_paths(self):
+        """Set full path information for plan files and their associated geometry and flow files."""
+        if self.plan_df.empty:
+            logger.debug("Plan DataFrame is empty, no paths to set")
+            return
+        
+        # Ensure full path is set for all plan entries
+        if 'full_path' not in self.plan_df.columns or self.plan_df['full_path'].isna().any():
+            self.plan_df['full_path'] = self.plan_df['plan_number'].apply(
+                lambda x: str(self.project_folder / f"{self.project_name}.p{x}")
+            )
+        
+        # Create the Geom Path and Flow Path columns if they don't exist
+        if 'Geom Path' not in self.plan_df.columns:
+            self.plan_df['Geom Path'] = None
+        if 'Flow Path' not in self.plan_df.columns:
+            self.plan_df['Flow Path'] = None
+        
+        # Update paths for each plan entry
+        for idx, row in self.plan_df.iterrows():
+            try:
+                # Set geometry path if Geom File exists and Geom Path is missing or invalid
+                if pd.notna(row['Geom File']):
+                    geom_path = self.project_folder / f"{self.project_name}.g{row['Geom File']}"
+                    self.plan_df.at[idx, 'Geom Path'] = str(geom_path)
+                
+                # Set flow path if Flow File exists and Flow Path is missing or invalid
+                if pd.notna(row['Flow File']):
+                    # Determine the prefix (u for unsteady, f for steady flow)
+                    prefix = 'u' if pd.notna(row['unsteady_number']) else 'f'
+                    flow_path = self.project_folder / f"{self.project_name}.{prefix}{row['Flow File']}"
+                    self.plan_df.at[idx, 'Flow Path'] = str(flow_path)
+                
+                if not self.suppress_logging:
+                    logger.debug(f"Plan {row['plan_number']} paths set up")
+            except Exception as e:
+                logger.error(f"Error setting paths for plan {row.get('plan_number', idx)}: {e}")
+
     def _get_geom_file_for_plan(self, plan_number):
         """
         Get the geometry file path for a given plan number.
@@ -939,33 +980,60 @@ class RasPrj:
             return df
         
         if entry_type == 'Plan':
-            # Define column groups
+            # Set required column order
             first_cols = ['plan_number', 'unsteady_number', 'geometry_number']
+            
+            # Standard plan key columns in the exact order specified
             plan_key_cols = [
                 'Plan Title', 'Program Version', 'Short Identifier', 'Simulation Date',
-                'Computation Interval', 'Mapping Interval', 'Run HTab', 'Run UNet', 
-                'Run Sediment', 'Run PostProcess', 'Run WQNet', 'UNET Use Existing IB Tables', 
-                'HDF_Results_Path', 'UNET 1D Methodology'
+                'Std Step Tol', 'Computation Interval', 'Output Interval', 'Instantaneous Interval',
+                'Mapping Interval', 'Run HTab', 'Run UNet', 'Run Sediment', 'Run PostProcess',
+                'Run WQNet', 'Run RASMapper', 'UNET Use Existing IB Tables', 'HDF_Results_Path',
+                'UNET 1D Methodology', 'Write IC File', 'Write IC File at Fixed DateTime',
+                'IC Time', 'Write IC File Reoccurance', 'Write IC File at Sim End'
             ]
+            
+            # Additional convenience columns
             file_path_cols = ['Geom File', 'Geom Path', 'Flow File', 'Flow Path']
             
-            # Build column list
+            # Special columns that must be preserved
+            special_cols = ['HDF_Results_Path']
+            
+            # Build the final column list
             all_cols = first_cols.copy()
-            all_cols.extend([col for col in plan_key_cols if col in df.columns])
-            all_cols.extend([col for col in df.columns if col not in all_cols + file_path_cols + ['full_path']])
+            
+            # Add plan key columns if they exist
+            for col in plan_key_cols:
+                if col in df.columns and col not in all_cols and col not in special_cols:
+                    all_cols.append(col)
+            
+            # Add any remaining columns not explicitly specified
+            other_cols = [col for col in df.columns if col not in all_cols + file_path_cols + special_cols + ['full_path']]
+            all_cols.extend(other_cols)
+            
+            # Add HDF_Results_Path if it exists (ensure it comes before file paths)
+            for special_col in special_cols:
+                if special_col in df.columns and special_col not in all_cols:
+                    all_cols.append(special_col)
+            
+            # Add file path columns at the end
             all_cols.extend(file_path_cols)
             
-            # Rename and fill missing columns
+            # Rename plan_number column
             df = df.rename(columns={f'{entry_type.lower()}_number': 'plan_number'})
+            
+            # Fill in missing columns with None
             for col in all_cols:
                 if col not in df.columns:
                     df[col] = None
             
-            # Add full_path if present
-            if 'full_path' in df.columns:
+            # Make sure full_path column is preserved and included
+            if 'full_path' in df.columns and 'full_path' not in all_cols:
                 all_cols.append('full_path')
             
-            return df[[col for col in all_cols if col in df.columns]]
+            # Return DataFrame with specified column order
+            cols_to_return = [col for col in all_cols if col in df.columns]
+            return df[cols_to_return]
         
         return df
 
@@ -1035,24 +1103,6 @@ class RasPrj:
             hdf_path = self.project_folder / f"{self.project_name}.p{entry_number}.hdf"
             entry['HDF_Results_Path'] = str(hdf_path) if hdf_path.exists() else None
 
-    def _set_plan_paths(self):
-        """Helper method to set paths in plan_df."""
-        if not self.plan_df['full_path'].any():
-            self.plan_df['full_path'] = self.plan_df['plan_number'].apply(
-                lambda x: str(self.project_folder / f"{self.project_name}.p{x}")
-            )
-        
-        for idx, row in self.plan_df.iterrows():
-            if pd.notna(row['Geom File']) and pd.isna(row.get('Geom Path')):
-                self.plan_df.at[idx, 'Geom Path'] = str(self.project_folder / f"{self.project_name}.g{row['Geom File']}")
-            
-            if pd.notna(row['Flow File']) and pd.isna(row.get('Flow Path')):
-                prefix = 'u' if pd.notna(row['unsteady_number']) else 'f'
-                self.plan_df.at[idx, 'Flow Path'] = str(self.project_folder / f"{self.project_name}.{prefix}{row['Flow File']}")
-            
-            if not self.suppress_logging:
-                logger.info(f"Plan {row['plan_number']} paths set up")
-
 
 # Create a global instance named 'ras'
 # Defining the global instance allows the init_ras_project function to initialize the project.

ras_commander/__init__.py

@@ -10,7 +10,7 @@ try:
     __version__ = version("ras-commander")
 except PackageNotFoundError:
     # package is not installed
-    __version__ = "0.66.0"
+    __version__ = "0.68.0"
 
 # Set up logging
 setup_logging()

{ras_commander-0.66.0.dist-info → ras_commander-0.68.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ras-commander
-Version: 0.66.0
+Version: 0.68.0
 Summary: A Python library for automating HEC-RAS 6.x operations
 Home-page: https://github.com/gpt-cmdr/ras-commander
 Author: William M. Katzenmeyer, P.E., C.F.M.

{ras_commander-0.66.0.dist-info → ras_commander-0.68.0.dist-info}/RECORD

@@ -1,14 +1,14 @@
-ras_commander/Decorators.py,sha256=0UIYc-hzmBVS7tovSLMzDp2NIhwrZvOYNrQSvETxhEE,6538
+ras_commander/Decorators.py,sha256=EOYi20fyV6JgArpHO3lQEVAU6LPHbpa3wGlmIYS40K0,10115
 ras_commander/HdfBase.py,sha256=Jws6Y8JFkharuiM6Br5ivp6MS64X2fL6y87FOpe3FQw,14219
 ras_commander/HdfBndry.py,sha256=FBNFoTz4sXVB-MOsbHJBP8P0dMqJUfBROloKTaxmzCo,16377
 ras_commander/HdfFluvialPluvial.py,sha256=dlqoFX5i7uSA2BvuRNrV-Fg-z2JaeUxY86_fbZAdGqI,25933
 ras_commander/HdfInfiltration.py,sha256=SB8EsB-w1zrUHXqn3G8ihEahViTIZF7c7AyPHIrSrOU,15473
 ras_commander/HdfMesh.py,sha256=zI_4AqxDxb2_31G9RUmWibyld6KDMGhDpI3F8qwzVAw,19139
 ras_commander/HdfPipe.py,sha256=m-yvPL2GIP23NKt2tcwzOlS7khvgcDPGAshlTPMUAeI,32154
-ras_commander/HdfPlan.py,sha256=jCNeyMHlaiMjn6wgGjVXrRElMSh3xwlmFJxHMzOkanM,12317
+ras_commander/HdfPlan.py,sha256=_KIWMoMpAftUp2wc2PQ9psl78IvW0disN0yKt7sNfqU,11807
 ras_commander/HdfPlot.py,sha256=7MNI5T9qIz-Ava1RdlnB6O9oJElE5BEB29QVF5Y2Xuc,3401
 ras_commander/HdfPump.py,sha256=Vc2ff16kRISR7jwtnaAqxI0p-gfBSuZKzR3rQbBLQoE,12951
-ras_commander/HdfResultsMesh.py,sha256=nO2dGYEvQiUWr19MAkkVAkU5AW3kKcps8d0zgox73u4,31738
+ras_commander/HdfResultsMesh.py,sha256=kjk5zXowgfscayiyKmSFdTDXa8-kPUI4SYKJ2okw3F0,31738
 ras_commander/HdfResultsPlan.py,sha256=L3IOdF6R3XiA7mbFAyLdczrZJQJogd8hhl7UYJWT5fY,16246
 ras_commander/HdfResultsPlot.py,sha256=ylzfT78CfgoDO0XAlRwlgMNRzvNQYBMn9eyXyBfjv_w,7660
 ras_commander/HdfResultsXsec.py,sha256=-P7nXnbjOLAeUnrdSC_lJQSfzrlWKmDF9Z5gEjmxbJY,13031
@@ -22,13 +22,13 @@ ras_commander/RasGeo.py,sha256=M0sVNKlWmmbve8iMXLWq25WgbxqLWBo7_1oDg_rALzU,5607
 ras_commander/RasGpt.py,sha256=N_7p2nucWrBBXdB2k2ZKvOeOdXNmFD9dIY3W7_5i5nw,1206
 ras_commander/RasMapper.py,sha256=LO_blvQnd4pwkEU8A30-RoE-CYIoU3s_fNLHBoM8ljw,613
 ras_commander/RasPlan.py,sha256=0THxeB9ldeDuS4of2ruYG7Abbc5jz2729y5qOHntMuI,61664
-ras_commander/RasPrj.py,sha256=gQoGG1Mqsoj5W1oVlulqhA0kQ5eD69vI96uihnY-kLE,47744
+ras_commander/RasPrj.py,sha256=uJ8jHq_Y5-ZnQW6nWhTuHFfaDGuMrJo1HQRvd1QwINQ,50228
 ras_commander/RasToGo.py,sha256=TKujfaV1xQhFaOddF4g2ogGy6ky-CLlfelSMPD2J3Nk,1223
 ras_commander/RasUnsteady.py,sha256=KfCXAag-_bPwwS3JbPZH-s4hbaoHACO0mlRnGrzbFgA,32092
 ras_commander/RasUtils.py,sha256=0fm4IIs0LH1dgDj3pGd66mR82DhWLEkRKUvIo2M_5X0,35886
-ras_commander/__init__.py,sha256=KICL5peRDDjE2BXEFVDMmtDZ4TKHtNhHh5eQgTSdqqs,2001
-ras_commander-0.66.0.dist-info/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
-ras_commander-0.66.0.dist-info/METADATA,sha256=-jPNaFlPs0iCcscfGjO31DwF3-LT632rbiunJQmYzoM,26233
-ras_commander-0.66.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-ras_commander-0.66.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
-ras_commander-0.66.0.dist-info/RECORD,,
+ras_commander/__init__.py,sha256=dVjDtqWMWjV2x17oJEEZQWwyvpqxJJM9s9_zHe0SJXY,2001
+ras_commander-0.68.0.dist-info/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
+ras_commander-0.68.0.dist-info/METADATA,sha256=4VhVogHKCjgJb-nGJgsiQ9O3nI0jUBAAx5D_Xd8SJcw,26233
+ras_commander-0.68.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+ras_commander-0.68.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
+ras_commander-0.68.0.dist-info/RECORD,,