ras-commander 0.65.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.