ras-commander 0.73.0__py3-none-any.whl → 0.75.0__py3-none-any.whl

ras_commander/Decorators.py

@@ -110,13 +110,17 @@ def standardize_input(file_type: str = 'plan_hdf'):
                     except Exception as e:
                         raise ValueError(f"RAS object is not initialized: {str(e)}")
                         
+                    # Extract the number part and strip leading zeros
                     number_str = hdf_input if hdf_input.isdigit() else hdf_input[1:]
-                    number_int = int(number_str)
+                    stripped_number = number_str.lstrip('0')
+                    if stripped_number == '':  # Handle case where input was '0' or '00'
+                        stripped_number = '0'
+                    number_int = int(stripped_number)
                     
                     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]
+                            # Convert plan_number column to integers for comparison after stripping zeros
+                            plan_info = ras_obj.plan_df[ras_obj.plan_df['plan_number'].str.lstrip('0').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']
@@ -128,12 +132,35 @@ def standardize_input(file_type: str = 'plan_hdf'):
 
                     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))
+                            # First try to get the geometry number from the plan
+                            from ras_commander import RasPlan
+                            plan_info = ras_obj.plan_df[ras_obj.plan_df['plan_number'].astype(int) == number_int]
+                            if not plan_info.empty:
+                                # Extract the geometry number from the plan
+                                geom_number = plan_info.iloc[0]['geometry_number']
+                                if pd.notna(geom_number) and geom_number is not None:
+                                    # Handle different types of geom_number (string or int)
+                                    try:
+                                        # Get the geometry path using RasPlan
+                                        geom_path = RasPlan.get_geom_path(str(geom_number), ras_obj)
+                                        
+                                        if geom_path is not None:
+                                            # Create the HDF path by adding .hdf to the geometry path
+                                            hdf_path = Path(str(geom_path) + ".hdf")
+                                            if hdf_path.exists():
+                                                logger.info(f"Found geometry HDF file for plan {number_int}: {hdf_path}")
+                                            else:
+                                                # Try to find it in the geom_df if direct path doesn't exist
+                                                geom_info = ras_obj.geom_df[ras_obj.geom_df['full_path'] == str(geom_path)]
+                                                if not geom_info.empty and 'hdf_path' in geom_info.columns:
+                                                    hdf_path_str = geom_info.iloc[0]['hdf_path']
+                                                    if pd.notna(hdf_path_str):
+                                                        hdf_path = Path(str(hdf_path_str))
+                                                        logger.info(f"Found geometry HDF file from geom_df for plan {number_int}: {hdf_path}")
+                                    except (TypeError, ValueError) as e:
+                                        logger.warning(f"Error processing geometry number {geom_number}: {str(e)}")
+                                else:
+                                    logger.warning(f"No valid geometry number found for plan {number_int}")
                         except Exception as e:
                             logger.warning(f"Error retrieving geometry HDF path: {str(e)}")
                     else:
@@ -153,8 +180,8 @@ def standardize_input(file_type: str = 'plan_hdf'):
                     
                     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]
+                            # Convert plan_number column to integers for comparison after stripping zeros
+                            plan_info = ras_obj.plan_df[ras_obj.plan_df['plan_number'].str.lstrip('0').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']
@@ -162,14 +189,38 @@ def standardize_input(file_type: str = 'plan_hdf'):
                                     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))
+                            # First try finding plan info to get geometry number
+                            plan_info = ras_obj.plan_df[ras_obj.plan_df['plan_number'].astype(int) == number_int]
+                            if not plan_info.empty:
+                                # Extract the geometry number from the plan
+                                geom_number = plan_info.iloc[0]['geometry_number']
+                                if pd.notna(geom_number) and geom_number is not None:
+                                    # Handle different types of geom_number (string or int)
+                                    try:
+                                        # Get the geometry path using RasPlan
+                                        from ras_commander import RasPlan
+                                        geom_path = RasPlan.get_geom_path(str(geom_number), ras_obj)
+                                        
+                                        if geom_path is not None:
+                                            # Create the HDF path by adding .hdf to the geometry path
+                                            hdf_path = Path(str(geom_path) + ".hdf")
+                                            if hdf_path.exists():
+                                                logger.info(f"Found geometry HDF file for plan {number_int}: {hdf_path}")
+                                            else:
+                                                # Try to find it in the geom_df if direct path doesn't exist
+                                                geom_info = ras_obj.geom_df[ras_obj.geom_df['full_path'] == str(geom_path)]
+                                                if not geom_info.empty and 'hdf_path' in geom_info.columns:
+                                                    hdf_path_str = geom_info.iloc[0]['hdf_path']
+                                                    if pd.notna(hdf_path_str):
+                                                        hdf_path = Path(str(hdf_path_str))
+                                                        logger.info(f"Found geometry HDF file from geom_df for plan {number_int}: {hdf_path}")
+                                    except (TypeError, ValueError) as e:
+                                        logger.warning(f"Error processing geometry number {geom_number}: {str(e)}")
+                                else:
+                                    logger.warning(f"No valid geometry number found for plan {number_int}")
                         except Exception as e:
                             logger.warning(f"Error retrieving geometry HDF path: {str(e)}")
                     else:

ras_commander/HdfPlan.py

@@ -280,17 +280,18 @@ class HdfPlan:
         Raises:
             ValueError: If Geometry group is missing or there's an error reading attributes.
         """
-        print(f"Getting geometry attributes from {hdf_path}")
+        logger.info(f"Getting geometry attributes from {hdf_path}")
         try:
             with h5py.File(hdf_path, 'r') as hdf_file:
                 geom_attrs_path = "Geometry"
-                print(f"Checking for Geometry group in {hdf_path}")
+                logger.info(f"Checking for Geometry group in {hdf_path}")
                 if geom_attrs_path not in hdf_file:
+                    logger.error(f"Geometry group not found in {hdf_path}")
                     raise ValueError(f"Geometry group not found in {hdf_path}")
 
                 attrs = {}
                 geom_group = hdf_file[geom_attrs_path]
-                print("Getting root level geometry attributes")
+                logger.info("Getting root level geometry attributes")
                 # Get root level geometry attributes only
                 for key, value in geom_group.attrs.items():
                     if isinstance(value, bytes):
@@ -300,13 +301,16 @@ class HdfPlan:
                             logger.warning(f"Failed to decode byte string for root attribute {key}")
                             continue
                     attrs[key] = value
+                    logger.debug(f"Geometry attribute: {key} = {value}")
 
-                print("Successfully extracted root level geometry attributes")
+                logger.info(f"Successfully extracted {len(attrs)} root level geometry attributes")
                 return pd.DataFrame.from_dict(attrs, orient='index', columns=['Value'])
 
         except (OSError, RuntimeError) as e:
+            logger.error(f"Failed to read HDF file {hdf_path}: {str(e)}")
             raise ValueError(f"Failed to read HDF file {hdf_path}: {str(e)}")
         except Exception as e:
+            logger.error(f"Failed to get geometry attributes: {str(e)}")
             raise ValueError(f"Failed to get geometry attributes: {str(e)}")
 
 

ras_commander/RasPlan.py

@@ -579,12 +579,12 @@ class RasPlan:
 
     @staticmethod
     @log_call
-    def get_geom_path(geom_number: str, ras_object=None) -> Optional[str]:
+    def get_geom_path(geom_number: Union[str, int], ras_object=None) -> Optional[str]:
         """
         Return the full path for a given geometry number.
 
         Args:
-        geom_number (str): The geometry number to search for.
+        geom_number (Union[str, int]): The geometry number to search for.
         ras_object (RasPrj, optional): Specific RAS object to use. If None, uses the global ras instance.
 
         Returns:
@@ -601,17 +601,51 @@ class RasPlan:
         ... else:
         ...     print("Geometry file not found.")
         """
-        ras_obj = ras_object or ras
-        ras_obj.check_initialized()
-        
-        # Use updated geom dataframe
-        ras_obj.geom_df = ras_obj.get_prj_entries('Geom')
+        logger = get_logger(__name__)
         
-        geom_path = ras_obj.geom_df[ras_obj.geom_df['geom_number'] == geom_number]
-        if not geom_path.empty:
-            full_path = geom_path['full_path'].iloc[0]
-            return full_path
-        else:
+        if geom_number is None:
+            logger.warning("Provided geometry number is None")
+            return None
+            
+        try:
+            ras_obj = ras_object or ras
+            ras_obj.check_initialized()
+            
+            # Ensure geom_number is a string with proper formatting
+            if isinstance(geom_number, int):
+                geom_number = f"{geom_number:02d}"
+            elif isinstance(geom_number, str):
+                # Strip any leading zeros and reformat
+                stripped = geom_number.lstrip('0')
+                if not stripped:  # Handle case where input was '0' or '00'
+                    geom_number = '00'
+                else:
+                    geom_number = f"{int(stripped):02d}"
+            else:
+                # Handle unexpected types
+                logger.warning(f"Unexpected type for geom_number: {type(geom_number)}")
+                return None
+            
+            # Use updated geom dataframe
+            ras_obj.geom_df = ras_obj.get_prj_entries('Geom')
+            
+            # Find the geometry file path
+            geom_path = ras_obj.geom_df[ras_obj.geom_df['geom_number'] == geom_number]
+            if not geom_path.empty:
+                if 'full_path' in geom_path.columns and pd.notna(geom_path['full_path'].iloc[0]):
+                    full_path = geom_path['full_path'].iloc[0]
+                    logger.info(f"Found geometry path: {full_path}")
+                    return full_path
+                else:
+                    # Fallback to constructing path
+                    constructed_path = str(ras_obj.project_folder / f"{ras_obj.project_name}.g{geom_number}")
+                    logger.info(f"Constructed geometry path: {constructed_path}")
+                    return constructed_path
+            else:
+                logger.warning(f"No geometry file found with number: {geom_number}")
+                return None
+        except Exception as e:
+            logger.error(f"Error in get_geom_path: {str(e)}")
             return None
 
     # Clone Functions to copy unsteady, flow, and geometry files from templates

ras_commander/RasPrj.py

@@ -1274,7 +1274,7 @@ def init_ras_project(ras_project_folder, ras_version=None, ras_object=None):
         ras_project_folder (str or Path): The path to the RAS project folder.
         ras_version (str, optional): The version of RAS to use (e.g., "6.6").
                                     Can also be a full path to the Ras.exe file.
-                                    If None, will attempt to use a default path.
+                                    If None, will attempt to detect from plan files.
         ras_object (RasPrj, optional): If None, updates the global 'ras' object.
                                        If a RasPrj instance, updates that instance.
                                        If any other value, creates and returns a new RasPrj instance.
@@ -1295,31 +1295,86 @@ def init_ras_project(ras_project_folder, ras_version=None, ras_object=None):
         >>> my_project = init_ras_project("/path/to/project", "6.6", "new")
         >>> print(f"Created project instance: {my_project.project_name}")
     """
-    if not Path(ras_project_folder).exists():
-        logger.error(f"The specified RAS project folder does not exist: {ras_project_folder}")
-        raise FileNotFoundError(f"The specified RAS project folder does not exist: {ras_project_folder}. Please check the path and try again.")
-
-    ras_exe_path = get_ras_exe(ras_version)
+    project_folder = Path(ras_project_folder)
+    if not project_folder.exists():
+        logger.error(f"The specified RAS project folder does not exist: {project_folder}")
+        raise FileNotFoundError(f"The specified RAS project folder does not exist: {project_folder}. Please check the path and try again.")
 
     # Determine which RasPrj instance to use
     if ras_object is None:
         # Use the global 'ras' object
-        logger.info("Initializing global 'ras' object via init_ras_project function.")
+        logger.debug("Initializing global 'ras' object via init_ras_project function.")
         ras_object = ras
     elif not isinstance(ras_object, RasPrj):
         # Create a new RasPrj instance
-        logger.info("Creating a new RasPrj instance.")
+        logger.debug("Creating a new RasPrj instance.")
         ras_object = RasPrj()
-
-    # Initialize the RasPrj instance
-    ras_object.initialize(ras_project_folder, ras_exe_path)
+    
+    ras_exe_path = None
+    
+    # Use version specified by user if provided
+    if ras_version is not None:
+        ras_exe_path = get_ras_exe(ras_version)
+        if ras_exe_path == "Ras.exe" and ras_version != "Ras.exe":
+            logger.warning(f"HEC-RAS Version {ras_version} was not found. Running HEC-RAS will fail.")
+    else:
+        # No version specified, try to detect from plan files
+        detected_version = None
+        logger.info("No HEC-RAS Version Specified.Attempting to detect HEC-RAS version from plan files.")
+        
+        # Look for .pXX files in project folder
+        logger.info(f"Searching for plan files in {project_folder}")
+        plan_files = list(project_folder.glob(f"{project_folder.stem}.p[0-9][0-9]"))
+        
+        if not plan_files:
+            logger.info(f"No plan files found in {project_folder}")
+        
+        for plan_file in plan_files:
+            logger.info(f"Found plan file: {plan_file.name}")
+            content, encoding = read_file_with_fallback_encoding(plan_file)
+            
+            if not content:
+                logger.info(f"Could not read content from {plan_file.name}")
+                continue
+                
+            logger.info(f"Successfully read plan file with {encoding} encoding")
+            
+            # Look for Program Version in plan file
+            for line in content.splitlines():
+                if line.startswith("Program Version="):
+                    version = line.split("=")[1].strip()
+                    logger.info(f"Found Program Version={version} in {plan_file.name}")
+                    
+                    # Try to get RAS executable for this version
+                    test_exe_path = get_ras_exe(version)
+                    logger.info(f"Checking RAS executable path: {test_exe_path}")
+                    
+                    if test_exe_path != "Ras.exe":
+                        detected_version = version
+                        ras_exe_path = test_exe_path
+                        logger.debug(f"Found valid HEC-RAS version {version} in plan file {plan_file.name}")
+                        break
+                    else:
+                        logger.info(f"Version {version} not found in default installation path")
+            
+            if detected_version:
+                break
+        
+        if not detected_version:
+            logger.error("No valid HEC-RAS version found in any plan files.")
+            ras_exe_path = "Ras.exe"
+            logger.warning("No valid HEC-RAS version was detected. Running HEC-RAS will fail.")
+    
+    # Initialize or re-initialize with the determined executable path
+    ras_object.initialize(project_folder, ras_exe_path)
     
     # Always update the global ras object as well
     if ras_object is not ras:
-        ras.initialize(ras_project_folder, ras_exe_path)
-        logger.info("Global 'ras' object also updated to match the new project.")
+        ras.initialize(project_folder, ras_exe_path)
+        logger.debug("Global 'ras' object also updated to match the new project.")
     
-    logger.info(f"Project initialized. ras_object project folder: {ras_object.project_folder}")
+    logger.debug(f"Project initialized. Project folder: {ras_object.project_folder}")
+    logger.debug(f"Using HEC-RAS executable: {ras_exe_path}")
     return ras_object
 
 @log_call
@@ -1331,36 +1386,29 @@ def get_ras_exe(ras_version=None):
     1. If ras_version is a valid file path to an .exe file, use that path
     2. If ras_version is a known version number, use default installation path
     3. If global 'ras' object has ras_exe_path, use that
-    4. As a fallback, return a default path (which may not exist)
+    4. As a fallback, return "Ras.exe" but log an error
     
     Args:
         ras_version (str, optional): Either a version number or a full path to the HEC-RAS executable.
     
     Returns:
-        str: The full path to the HEC-RAS executable.
+        str: The full path to the HEC-RAS executable or "Ras.exe" if not found.
     
     Note:
         - HEC-RAS version numbers include: "6.6", "6.5", "6.4.1", "6.3", etc.
         - The default installation path follows: C:/Program Files (x86)/HEC/HEC-RAS/{version}/Ras.exe
-        - Returns a default path ("Ras.exe") if no valid path is found
-        - This allows the library to function even without HEC-RAS installed
-        
-    Example:
-        >>> # Get path for specific version
-        >>> ras_path = get_ras_exe("6.6")
-        >>> print(f"HEC-RAS 6.6 executable: {ras_path}")
-        >>>
-        >>> # Provide direct path to executable
-        >>> custom_path = get_ras_exe("C:/My_Programs/HEC-RAS/Ras.exe")
+        - Returns "Ras.exe" if no valid path is found, with error logged
+        - Allows the library to function even without HEC-RAS installed
     """
     if ras_version is None:
         if hasattr(ras, 'ras_exe_path') and ras.ras_exe_path:
             logger.debug(f"Using HEC-RAS executable from global 'ras' object: {ras.ras_exe_path}")
             return ras.ras_exe_path
         else:
-            default_path = Path("Ras.exe")
-            logger.warning(f"No HEC-RAS version specified and global 'ras' object not initialized or missing ras_exe_path. Using default path: {default_path}. The RAS Commander (ras-commander) Library Assistant can ignore this error since it does not have HEC-RAS installed.")
-            return str(default_path)
+            default_path = "Ras.exe"
+            logger.debug(f"No HEC-RAS version specified and global 'ras' object not initialized or missing ras_exe_path.")
+            logger.warning(f"HEC-RAS is not installed or version not specified. Running HEC-RAS will fail unless a valid installed version is specified.")
+            return default_path
     
     ras_version_numbers = [
         "6.6", "6.5", "6.4.1", "6.3.1", "6.3", "6.2", "6.1", "6.0",
@@ -1368,32 +1416,54 @@ def get_ras_exe(ras_version=None):
         "4.1", "4.0", "3.1.3", "3.1.2", "3.1.1", "3.0", "2.2"
     ]
     
+    # Check if input is a direct path to an executable
     hecras_path = Path(ras_version)
-    
     if hecras_path.is_file() and hecras_path.suffix.lower() == '.exe':
         logger.debug(f"HEC-RAS executable found at specified path: {hecras_path}")
         return str(hecras_path)
     
-    if ras_version in ras_version_numbers:
+    # Check known version numbers
+    if str(ras_version) in ras_version_numbers:
         default_path = Path(f"C:/Program Files (x86)/HEC/HEC-RAS/{ras_version}/Ras.exe")
         if default_path.is_file():
             logger.debug(f"HEC-RAS executable found at default path: {default_path}")
             return str(default_path)
         else:
-            logger.critical(f"HEC-RAS executable not found at the expected path: {default_path}")
+            error_msg = f"HEC-RAS Version {ras_version} is not found at expected path. Running HEC-RAS will fail unless a valid installed version is specified."
+            logger.error(error_msg)
+            return "Ras.exe"
     
+    # Try to handle other version formats (e.g., just the number without dots)
     try:
-        version_float = float(ras_version)
-        if version_float > max(float(v) for v in ras_version_numbers):
-            newer_version_path = Path(f"C:/Program Files (x86)/HEC/HEC-RAS/{ras_version}/Ras.exe")
-            if newer_version_path.is_file():
-                logger.debug(f"Newer version of HEC-RAS executable found at: {newer_version_path}")
-                return str(newer_version_path)
-            else:
-                logger.critical("Newer version of HEC-RAS was specified, but the executable was not found.")
-    except ValueError:
-        pass
-    
-    logger.error(f"Invalid HEC-RAS version or path: {ras_version}, returning default path: {default_path}")
-    return str(default_path)
+        # First check if it's a direct version number
+        version_str = str(ras_version)
+        
+        # Check for paths like "C:/Path/To/Ras.exe"
+        if os.path.sep in version_str and version_str.lower().endswith('.exe'):
+            exe_path = Path(version_str)
+            if exe_path.is_file():
+                logger.debug(f"HEC-RAS executable found at specified path: {exe_path}")
+                return str(exe_path)
+        
+        # Try to find a matching version from our list
+        for known_version in ras_version_numbers:
+            if version_str in known_version or known_version.replace('.', '') == version_str:
+                default_path = Path(f"C:/Program Files (x86)/HEC/HEC-RAS/{known_version}/Ras.exe")
+                if default_path.is_file():
+                    logger.debug(f"HEC-RAS executable found at default path: {default_path}")
+                    return str(default_path)
+        
+        # Check if it's a newer version
+        if '.' in version_str:
+            major_version = int(version_str.split('.')[0])
+            if major_version >= 6:
+                default_path = Path(f"C:/Program Files (x86)/HEC/HEC-RAS/{version_str}/Ras.exe")
+                if default_path.is_file():
+                    logger.debug(f"HEC-RAS executable found at path for newer version: {default_path}")
+                    return str(default_path)
+    except Exception as e:
+        logger.error(f"Error parsing version or finding path: {e}")
     
+    error_msg = f"HEC-RAS Version {ras_version} is not recognized or installed. Running HEC-RAS will fail unless a valid installed version is specified."
+    logger.error(error_msg)
+    return "Ras.exe"

ras_commander/__init__.py

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

{ras_commander-0.73.0.dist-info → ras_commander-0.75.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ras-commander
-Version: 0.73.0
+Version: 0.75.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.73.0.dist-info → ras_commander-0.75.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-ras_commander/Decorators.py,sha256=EOYi20fyV6JgArpHO3lQEVAU6LPHbpa3wGlmIYS40K0,10115
+ras_commander/Decorators.py,sha256=mhfM6A8jJTZ9b0srybB3u4DIaDnwweVQqYHERLR62Ck,14527
 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=HiifhbzgUs4kdtJkKfhxo1IsE-FBp5XspKkrJnnCDuc,66171
 ras_commander/HdfMesh.py,sha256=zI_4AqxDxb2_31G9RUmWibyld6KDMGhDpI3F8qwzVAw,19139
 ras_commander/HdfPipe.py,sha256=m-yvPL2GIP23NKt2tcwzOlS7khvgcDPGAshlTPMUAeI,32154
-ras_commander/HdfPlan.py,sha256=_KIWMoMpAftUp2wc2PQ9psl78IvW0disN0yKt7sNfqU,11807
+ras_commander/HdfPlan.py,sha256=WINI3lp865cE99QXztgvKKIhVUTOqu4X41ZPBfhYJGU,12145
 ras_commander/HdfPlot.py,sha256=7MNI5T9qIz-Ava1RdlnB6O9oJElE5BEB29QVF5Y2Xuc,3401
 ras_commander/HdfPump.py,sha256=Vc2ff16kRISR7jwtnaAqxI0p-gfBSuZKzR3rQbBLQoE,12951
 ras_commander/HdfResultsMesh.py,sha256=MKnSJxcWVDccHaRRGgAK0szm7B-VtrKBtgL1Uz0kAiw,44662
@@ -20,13 +20,13 @@ ras_commander/RasCmdr.py,sha256=37GnchoQ0fIAkPnssnCr1mRUXY8gm-hIMTmuHZlnYP8,3459
 ras_commander/RasExamples.py,sha256=6IZ96LcAsk5LYFehdD0zDW5wyZWxQa6OQu2N9upxWXA,17536
 ras_commander/RasGeo.py,sha256=CQ1VjJ4uWWyXC9KsoVStbhlRf_5AiDm8yWvtDM3l4ac,21675
 ras_commander/RasMap.py,sha256=4cVzaaQure-CXdXB1BY29iE20S00eldUqoL96PvJPbw,10635
-ras_commander/RasPlan.py,sha256=7cgwsKjD40ZSj9uOnsHd-OfmBJFxkS2xFhWmlHQflak,62179
-ras_commander/RasPrj.py,sha256=ivAHB3vexH6GQi-Aa4kqAabRwdthllMkTp8xphh5Ldc,57655
+ras_commander/RasPlan.py,sha256=GhAeUSvWRuBcYcOtBCo-qZGUefEWOlhw4ASJQHTGWzU,63872
+ras_commander/RasPrj.py,sha256=G8AL6No0unxYLc1y0uQgcFLXeZ2TK3RO1WZmsZqAz7c,61281
 ras_commander/RasUnsteady.py,sha256=TO08CT2GC4G5rcXO_Wbia2t4PhiWRu9-nC9F0IW7Gyo,37187
 ras_commander/RasUtils.py,sha256=0fm4IIs0LH1dgDj3pGd66mR82DhWLEkRKUvIo2M_5X0,35886
-ras_commander/__init__.py,sha256=Tl8kx5SQQ8UocWSQ1tFzg4FGNb702k2yikfD6_hwXIw,2039
-ras_commander-0.73.0.dist-info/licenses/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
-ras_commander-0.73.0.dist-info/METADATA,sha256=GiwhfJNCCL8ZH9XY1bpVa3huCeU84E1oOr7zIlrj4vs,27365
-ras_commander-0.73.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-ras_commander-0.73.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
-ras_commander-0.73.0.dist-info/RECORD,,
+ras_commander/__init__.py,sha256=8QLpMI_g0OsRBnap8u71IviaH6cgWfq40xd8IbIavWw,2039
+ras_commander-0.75.0.dist-info/licenses/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
+ras_commander-0.75.0.dist-info/METADATA,sha256=o57ambIJOv_f_XYOccu5_3uhaNIZuGIAnxWDFf_8EJc,27365
+ras_commander-0.75.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+ras_commander-0.75.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
+ras_commander-0.75.0.dist-info/RECORD,,