ras-commander 0.66.0__tar.gz → 0.67.0__tar.gz

{ras_commander-0.66.0/ras_commander.egg-info → ras_commander-0.67.0}/PKG-INFO

@@ -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.67.0/ras_commander/Decorators.py

@@ -0,0 +1,184 @@
+from functools import wraps
+from pathlib import Path
+from typing import Union
+import logging
+import h5py
+import inspect
+import pandas as pd
+
+
+def log_call(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        logger = logging.getLogger(func.__module__)
+        logger.debug(f"Calling {func.__name__}")
+        result = func(*args, **kwargs)
+        logger.debug(f"Finished {func.__name__}")
+        return result
+    return wrapper
+
+def standardize_input(file_type: str = 'plan_hdf'):
+    """
+    Decorator to standardize input for HDF file operations.
+    
+    This decorator processes various input types and converts them to a Path object
+    pointing to the correct HDF file. It handles the following input types:
+    - h5py.File objects
+    - pathlib.Path objects
+    - Strings (file paths or plan/geom numbers)
+    - Integers (interpreted as plan/geom numbers)
+    
+    The decorator also manages RAS object references and logging.
+    
+    Args:
+        file_type (str): Specifies whether to look for 'plan_hdf' or 'geom_hdf' files.
+    
+    Returns:
+        A decorator that wraps the function to standardize its input to a Path object.
+    """
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            logger = logging.getLogger(func.__module__)
+            
+            # Check if the function expects an hdf_path parameter
+            sig = inspect.signature(func)
+            param_names = list(sig.parameters.keys())
+                
+            # 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 (args[0] if args else None)
+            
+            # Import ras here to ensure we get the most current instance
+            from .RasPrj import ras as ras
+            ras_object = kwargs.pop('ras_object', None) or (args[1] if len(args) > 1 else None)
+            ras_obj = ras_object or ras
+
+            # If no hdf_input provided, return the function unmodified
+            if hdf_input is None:
+                return func(*args, **kwargs)
+
+            hdf_path = None
+
+            # 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
+                    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)}")
+                        
+                    number_str = hdf_input if hdf_input.isdigit() else hdf_input[1:]
+                    number_int = int(number_str)
+                    
+                    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}")
+                
+                # 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}")
+
+            # 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"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:]
+            return func(*new_args, **kwargs)
+
+        return wrapper
+    return decorator

{ras_commander-0.66.0 → ras_commander-0.67.0}/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-0.66.0 → ras_commander-0.67.0}/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-0.66.0 → ras_commander-0.67.0}/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 → ras_commander-0.67.0/ras_commander.egg-info}/PKG-INFO

@@ -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 → ras_commander-0.67.0}/setup.py

@@ -28,7 +28,7 @@ class CustomBuildPy(build_py):
 
 setup(
     name="ras-commander",
-    version="0.66.0",
+    version="0.67.0",
     packages=find_packages(),
     include_package_data=True,
     python_requires='>=3.10',

ras_commander-0.66.0/ras_commander/Decorators.py

@@ -1,144 +0,0 @@
-from functools import wraps
-from pathlib import Path
-from typing import Union
-import logging
-import h5py
-import inspect
-
-
-def log_call(func):
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        logger = logging.getLogger(func.__module__)
-        logger.debug(f"Calling {func.__name__}")
-        result = func(*args, **kwargs)
-        logger.debug(f"Finished {func.__name__}")
-        return result
-    return wrapper
-
-def standardize_input(file_type: str = 'plan_hdf'):
-    """
-    Decorator to standardize input for HDF file operations.
-    
-    This decorator processes various input types and converts them to a Path object
-    pointing to the correct HDF file. It handles the following input types:
-    - h5py.File objects
-    - pathlib.Path objects
-    - Strings (file paths or plan/geom numbers)
-    - Integers (interpreted as plan/geom numbers)
-    
-    The decorator also manages RAS object references and logging.
-    
-    Args:
-        file_type (str): Specifies whether to look for 'plan_hdf' or 'geom_hdf' files.
-    
-    Returns:
-        A decorator that wraps the function to standardize its input to a Path object.
-    """
-    def decorator(func):
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            logger = logging.getLogger(func.__module__)
-            
-            # 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)
-            
-            # Import ras here to ensure we get the most current instance
-            from .RasPrj import ras as ras
-            ras_object = kwargs.pop('ras_object', None) or (args[1] if len(args) > 1 else None)
-            ras_obj = ras_object or ras
-
-            # If no hdf_input provided, return the function unmodified
-            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():
-                    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()):
-                    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'])
-                    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':
-                    # 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}")
-
-            if hdf_path is None or not hdf_path.is_file():
-                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}")
-            
-            # Pass all original arguments and keywords, replacing hdf_input with standardized hdf_path
-            new_args = (hdf_path,) + args[1:]
-            return func(*new_args, **kwargs)
-
-        return wrapper
-    return decorator