ras-commander 0.66.0__py3-none-any.whl → 0.67.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):
@@ -43,17 +44,13 @@ def standardize_input(file_type: str = 'plan_hdf'):
             # Check if the function expects an hdf_path parameter
             sig = inspect.signature(func)
             param_names = list(sig.parameters.keys())
-            
-            # If first parameter is 'hdf_file', skip path processing
-            if param_names and param_names[0] == 'hdf_file':
-                return func(*args, **kwargs)
                 
             # 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)
+            hdf_input = kwargs.pop('hdf_path', None) or (args[0] if args else None)
             
             # Import ras here to ensure we get the most current instance
             from .RasPrj import ras as ras
@@ -64,77 +61,120 @@ 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 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_str = geom_info.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 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_str = geom_info.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:]

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/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.67.0"
 
 # Set up logging
 setup_logging()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ras-commander
-Version: 0.66.0
+Version: 0.67.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.67.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-ras_commander/Decorators.py,sha256=0UIYc-hzmBVS7tovSLMzDp2NIhwrZvOYNrQSvETxhEE,6538
+ras_commander/Decorators.py,sha256=giQ19IQJChkDcnHoKVwnnbFKY6x-5uxASYOSodN14yU,9162
 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
@@ -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=ASXRYlvFpiyJZK6ux66G6qewZzn7Rv-asp8gaoUwXec,2001
+ras_commander-0.67.0.dist-info/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
+ras_commander-0.67.0.dist-info/METADATA,sha256=dDMBQFA7BG5_dSShvQz1GXssrGbklkJ-Am0EX91Zx2A,26233
+ras_commander-0.67.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+ras_commander-0.67.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
+ras_commander-0.67.0.dist-info/RECORD,,