ras-commander 0.80.2__py3-none-any.whl → 0.81.0__py3-none-any.whl

ras_commander/HdfResultsPlan.py

@@ -6,14 +6,23 @@ Attribution:
     Copyright (c) 2024 fema-ffrd, MIT license
 
 Description:
-    Provides static methods for extracting unsteady flow results, volume accounting,
-    and reference data from HEC-RAS plan HDF files.
+    Provides static methods for extracting both unsteady and steady flow results,
+    volume accounting, and reference data from HEC-RAS plan HDF files.
 
 Available Functions:
-    - get_unsteady_info: Extract unsteady attributes
-    - get_unsteady_summary: Extract unsteady summary data
-    - get_volume_accounting: Extract volume accounting data
-    - get_runtime_data: Extract runtime and compute time data
+    Unsteady Flow:
+        - get_unsteady_info: Extract unsteady attributes
+        - get_unsteady_summary: Extract unsteady summary data
+        - get_volume_accounting: Extract volume accounting data
+        - get_runtime_data: Extract runtime and compute time data
+        - get_reference_timeseries: Extract reference line/point timeseries
+        - get_reference_summary: Extract reference line/point summary
+
+    Steady Flow:
+        - is_steady_plan: Check if HDF contains steady state results
+        - get_steady_profile_names: Extract steady state profile names
+        - get_steady_wse: Extract WSE data for steady state profiles
+        - get_steady_info: Extract steady flow attributes and metadata
 
 Note:
     All methods are static and designed to be used without class instantiation.
@@ -378,4 +387,326 @@ class HdfResultsPlan:
 
         except Exception as e:
             logger.error(f"Error reading reference {reftype} summary: {str(e)}")
-            return pd.DataFrame()
+            return pd.DataFrame()
+
+    # ==================== STEADY STATE METHODS ====================
+
+    @staticmethod
+    @log_call
+    @standardize_input(file_type='plan_hdf')
+    def is_steady_plan(hdf_path: Path) -> bool:
+        """
+        Check if HDF file contains steady state results.
+
+        Args:
+            hdf_path (Path): Path to HEC-RAS plan HDF file
+            ras_object (RasPrj, optional): Specific RAS object to use. If None, uses the global ras instance.
+
+        Returns:
+            bool: True if the HDF contains steady state results, False otherwise
+
+        Notes:
+            - Checks for existence of Results/Steady group
+            - Does not guarantee results are complete or valid
+        """
+        try:
+            with h5py.File(hdf_path, 'r') as hdf_file:
+                return "Results/Steady" in hdf_file
+        except Exception as e:
+            logger.error(f"Error checking if plan is steady: {str(e)}")
+            return False
+
+    @staticmethod
+    @log_call
+    @standardize_input(file_type='plan_hdf')
+    def get_steady_profile_names(hdf_path: Path) -> List[str]:
+        """
+        Extract profile names from steady state results.
+
+        Args:
+            hdf_path (Path): Path to HEC-RAS plan HDF file
+            ras_object (RasPrj, optional): Specific RAS object to use. If None, uses the global ras instance.
+
+        Returns:
+            List[str]: List of profile names (e.g., ['50Pct', '10Pct', '1Pct'])
+
+        Raises:
+            FileNotFoundError: If the specified HDF file is not found
+            KeyError: If steady state results or profile names are not found
+            ValueError: If the plan is not a steady state plan
+
+        Example:
+            >>> from ras_commander import HdfResultsPlan, init_ras_project
+            >>> init_ras_project(Path('/path/to/project'), '6.6')
+            >>> profiles = HdfResultsPlan.get_steady_profile_names('01')
+            >>> print(profiles)
+            ['50Pct', '20Pct', '10Pct', '4Pct', '2Pct', '1Pct', '0.2Pct']
+        """
+        try:
+            with h5py.File(hdf_path, 'r') as hdf_file:
+                # Check if this is a steady state plan
+                if "Results/Steady" not in hdf_file:
+                    raise ValueError(f"HDF file does not contain steady state results: {hdf_path.name}")
+
+                # Path to profile names
+                profile_names_path = "Results/Steady/Output/Output Blocks/Base Output/Steady Profiles/Profile Names"
+
+                if profile_names_path not in hdf_file:
+                    raise KeyError(f"Profile names not found at: {profile_names_path}")
+
+                # Read profile names dataset
+                profile_names_ds = hdf_file[profile_names_path]
+                profile_names_raw = profile_names_ds[()]
+
+                # Decode byte strings to regular strings
+                profile_names = []
+                for name in profile_names_raw:
+                    if isinstance(name, bytes):
+                        profile_names.append(name.decode('utf-8').strip())
+                    else:
+                        profile_names.append(str(name).strip())
+
+                logger.info(f"Found {len(profile_names)} steady state profiles: {profile_names}")
+                return profile_names
+
+        except FileNotFoundError:
+            raise FileNotFoundError(f"HDF file not found: {hdf_path}")
+        except KeyError as e:
+            raise KeyError(f"Error accessing steady state profile names: {str(e)}")
+        except Exception as e:
+            raise RuntimeError(f"Error reading steady state profile names: {str(e)}")
+
+    @staticmethod
+    @log_call
+    @standardize_input(file_type='plan_hdf')
+    def get_steady_wse(
+        hdf_path: Path,
+        profile_index: Optional[int] = None,
+        profile_name: Optional[str] = None
+    ) -> pd.DataFrame:
+        """
+        Extract water surface elevation (WSE) data for steady state profiles.
+
+        Args:
+            hdf_path (Path): Path to HEC-RAS plan HDF file
+            profile_index (int, optional): Index of profile to extract (0-based). If None, extracts all profiles.
+            profile_name (str, optional): Name of profile to extract (e.g., '1Pct'). If specified, overrides profile_index.
+            ras_object (RasPrj, optional): Specific RAS object to use. If None, uses the global ras instance.
+
+        Returns:
+            pd.DataFrame: DataFrame containing WSE data with columns:
+                - River: River name
+                - Reach: Reach name
+                - Station: Cross section river station
+                - Profile: Profile name (if multiple profiles)
+                - WSE: Water surface elevation (ft)
+
+        Raises:
+            FileNotFoundError: If the specified HDF file is not found
+            KeyError: If steady state results or WSE data are not found
+            ValueError: If profile_index or profile_name is invalid
+
+        Example:
+            >>> # Extract single profile by index
+            >>> wse_df = HdfResultsPlan.get_steady_wse('01', profile_index=5)  # 100-year profile
+
+            >>> # Extract single profile by name
+            >>> wse_df = HdfResultsPlan.get_steady_wse('01', profile_name='1Pct')
+
+            >>> # Extract all profiles
+            >>> wse_df = HdfResultsPlan.get_steady_wse('01')
+        """
+        try:
+            with h5py.File(hdf_path, 'r') as hdf_file:
+                # Check if this is a steady state plan
+                if "Results/Steady" not in hdf_file:
+                    raise ValueError(f"HDF file does not contain steady state results: {hdf_path.name}")
+
+                # Paths to data
+                wse_path = "Results/Steady/Output/Output Blocks/Base Output/Steady Profiles/Cross Sections/Water Surface"
+                xs_attrs_path = "Results/Steady/Output/Geometry Info/Cross Section Attributes"
+                profile_names_path = "Results/Steady/Output/Output Blocks/Base Output/Steady Profiles/Profile Names"
+
+                # Check required paths exist
+                if wse_path not in hdf_file:
+                    raise KeyError(f"WSE data not found at: {wse_path}")
+                if xs_attrs_path not in hdf_file:
+                    raise KeyError(f"Cross section attributes not found at: {xs_attrs_path}")
+
+                # Get WSE dataset (shape: num_profiles × num_cross_sections)
+                wse_ds = hdf_file[wse_path]
+                wse_data = wse_ds[()]
+                num_profiles, num_xs = wse_data.shape
+
+                # Get profile names
+                if profile_names_path in hdf_file:
+                    profile_names_raw = hdf_file[profile_names_path][()]
+                    profile_names = [
+                        name.decode('utf-8').strip() if isinstance(name, bytes) else str(name).strip()
+                        for name in profile_names_raw
+                    ]
+                else:
+                    # Fallback to numbered profiles
+                    profile_names = [f"Profile_{i+1}" for i in range(num_profiles)]
+
+                # Get cross section attributes
+                xs_attrs = hdf_file[xs_attrs_path][()]
+
+                # Determine which profiles to extract
+                if profile_name is not None:
+                    # Find profile by name
+                    try:
+                        profile_idx = profile_names.index(profile_name)
+                    except ValueError:
+                        raise ValueError(
+                            f"Profile name '{profile_name}' not found. "
+                            f"Available profiles: {profile_names}"
+                        )
+                    profiles_to_extract = [(profile_idx, profile_name)]
+
+                elif profile_index is not None:
+                    # Validate profile index
+                    if profile_index < 0 or profile_index >= num_profiles:
+                        raise ValueError(
+                            f"Profile index {profile_index} out of range. "
+                            f"Valid range: 0 to {num_profiles-1}"
+                        )
+                    profiles_to_extract = [(profile_index, profile_names[profile_index])]
+
+                else:
+                    # Extract all profiles
+                    profiles_to_extract = list(enumerate(profile_names))
+
+                # Build DataFrame
+                rows = []
+                for prof_idx, prof_name in profiles_to_extract:
+                    wse_values = wse_data[prof_idx, :]
+
+                    for xs_idx in range(num_xs):
+                        river = xs_attrs[xs_idx]['River']
+                        reach = xs_attrs[xs_idx]['Reach']
+                        station = xs_attrs[xs_idx]['Station']
+
+                        # Decode byte strings
+                        river = river.decode('utf-8') if isinstance(river, bytes) else str(river)
+                        reach = reach.decode('utf-8') if isinstance(reach, bytes) else str(reach)
+                        station = station.decode('utf-8') if isinstance(station, bytes) else str(station)
+
+                        row = {
+                            'River': river.strip(),
+                            'Reach': reach.strip(),
+                            'Station': station.strip(),
+                            'WSE': float(wse_values[xs_idx])
+                        }
+
+                        # Only add Profile column if extracting multiple profiles
+                        if len(profiles_to_extract) > 1:
+                            row['Profile'] = prof_name
+
+                        rows.append(row)
+
+                df = pd.DataFrame(rows)
+
+                # Reorder columns
+                if 'Profile' in df.columns:
+                    df = df[['River', 'Reach', 'Station', 'Profile', 'WSE']]
+                else:
+                    df = df[['River', 'Reach', 'Station', 'WSE']]
+
+                logger.info(
+                    f"Extracted WSE data for {len(profiles_to_extract)} profile(s), "
+                    f"{num_xs} cross sections"
+                )
+
+                return df
+
+        except FileNotFoundError:
+            raise FileNotFoundError(f"HDF file not found: {hdf_path}")
+        except KeyError as e:
+            raise KeyError(f"Error accessing steady state WSE data: {str(e)}")
+        except Exception as e:
+            raise RuntimeError(f"Error reading steady state WSE data: {str(e)}")
+
+    @staticmethod
+    @log_call
+    @standardize_input(file_type='plan_hdf')
+    def get_steady_info(hdf_path: Path) -> pd.DataFrame:
+        """
+        Get steady flow attributes and metadata from HEC-RAS HDF plan file.
+
+        Args:
+            hdf_path (Path): Path to HEC-RAS plan HDF file
+            ras_object (RasPrj, optional): Specific RAS object to use. If None, uses the global ras instance.
+
+        Returns:
+            pd.DataFrame: DataFrame containing steady flow attributes including:
+                - Program Name
+                - Program Version
+                - Type of Run
+                - Run Time Window
+                - Solution status
+                - And other metadata attributes
+
+        Raises:
+            FileNotFoundError: If the specified HDF file is not found
+            KeyError: If steady state results are not found
+            ValueError: If the plan is not a steady state plan
+
+        Example:
+            >>> info_df = HdfResultsPlan.get_steady_info('01')
+            >>> print(info_df['Solution'].values[0])
+            'Steady Finished Successfully'
+        """
+        try:
+            with h5py.File(hdf_path, 'r') as hdf_file:
+                # Check if this is a steady state plan
+                if "Results/Steady" not in hdf_file:
+                    raise ValueError(f"HDF file does not contain steady state results: {hdf_path.name}")
+
+                attrs_dict = {}
+
+                # Get attributes from Results/Steady/Output
+                output_path = "Results/Steady/Output"
+                if output_path in hdf_file:
+                    output_group = hdf_file[output_path]
+                    for key, value in output_group.attrs.items():
+                        if isinstance(value, bytes):
+                            attrs_dict[key] = value.decode('utf-8')
+                        else:
+                            attrs_dict[key] = value
+
+                # Get attributes from Results/Steady/Summary
+                summary_path = "Results/Steady/Summary"
+                if summary_path in hdf_file:
+                    summary_group = hdf_file[summary_path]
+                    for key, value in summary_group.attrs.items():
+                        if isinstance(value, bytes):
+                            attrs_dict[key] = value.decode('utf-8')
+                        else:
+                            attrs_dict[key] = value
+
+                # Add flow file information from Plan Data
+                plan_info_path = "Plan Data/Plan Information"
+                if plan_info_path in hdf_file:
+                    plan_info = hdf_file[plan_info_path]
+                    for key in ['Flow Filename', 'Flow Title']:
+                        if key in plan_info.attrs:
+                            value = plan_info.attrs[key]
+                            if isinstance(value, bytes):
+                                attrs_dict[key] = value.decode('utf-8')
+                            else:
+                                attrs_dict[key] = value
+
+                if not attrs_dict:
+                    logger.warning("No steady state attributes found in HDF file")
+                    return pd.DataFrame()
+
+                logger.info(f"Extracted {len(attrs_dict)} steady state attributes")
+                return pd.DataFrame(attrs_dict, index=[0])
+
+        except FileNotFoundError:
+            raise FileNotFoundError(f"HDF file not found: {hdf_path}")
+        except KeyError as e:
+            raise KeyError(f"Error accessing steady state info: {str(e)}")
+        except Exception as e:
+            raise RuntimeError(f"Error reading steady state info: {str(e)}")

ras_commander/RasPrj.py

@@ -116,7 +116,7 @@ class RasPrj:
         self.suppress_logging = False  # Add suppress_logging as instance variable
 
     @log_call
-    def initialize(self, project_folder, ras_exe_path, suppress_logging=True):
+    def initialize(self, project_folder, ras_exe_path, suppress_logging=True, prj_file=None):
         """
         Initialize a RasPrj instance with project folder and RAS executable path.
 
@@ -127,13 +127,16 @@ class RasPrj:
             project_folder (str or Path): Path to the HEC-RAS project folder.
             ras_exe_path (str or Path): Path to the HEC-RAS executable.
             suppress_logging (bool, default=True): If True, suppresses initialization logging messages.
+            prj_file (str or Path, optional): If provided, use this specific .prj file instead of searching.
+                                              This is used when user specifies a .prj file directly.
 
         Raises:
-            ValueError: If no HEC-RAS project file is found in the specified folder.
+            ValueError: If no HEC-RAS project file is found in the specified folder,
+                        or if the specified prj_file doesn't exist or is invalid.
 
         Note:
             This method sets up the RasPrj instance by:
-            1. Finding the project file (.prj)
+            1. Finding the project file (.prj) or using the provided prj_file
             2. Loading project data (plans, geometries, flows)
             3. Extracting boundary conditions
             4. Setting the initialization flag
@@ -141,10 +144,21 @@ class RasPrj:
         """
         self.suppress_logging = suppress_logging  # Store suppress_logging state
         self.project_folder = Path(project_folder)
-        self.prj_file = self.find_ras_prj(self.project_folder)
-        if self.prj_file is None:
-            logger.error(f"No HEC-RAS project file found in {self.project_folder}")
-            raise ValueError(f"No HEC-RAS project file found in {self.project_folder}. Please check the path and try again.")
+
+        # If user specified a .prj file directly, use it (Phase 2 optimization)
+        if prj_file is not None:
+            self.prj_file = Path(prj_file).resolve()
+            if not self.prj_file.exists():
+                logger.error(f"Specified .prj file does not exist: {self.prj_file}")
+                raise ValueError(f"Specified .prj file does not exist: {self.prj_file}. Please check the path and try again.")
+            logger.debug(f"Using specified .prj file: {self.prj_file}")
+        else:
+            # Search for .prj file (existing behavior)
+            self.prj_file = self.find_ras_prj(self.project_folder)
+            if self.prj_file is None:
+                logger.error(f"No HEC-RAS project file found in {self.project_folder}")
+                raise ValueError(f"No HEC-RAS project file found in {self.project_folder}. Please check the path and try again.")
+
         self.project_name = Path(self.prj_file).stem
         self.ras_exe_path = ras_exe_path
         
@@ -204,10 +218,19 @@ 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()
-            
+
+            # Add flow_type column for deterministic steady/unsteady identification
+            if not self.plan_df.empty and 'unsteady_number' in self.plan_df.columns:
+                self.plan_df['flow_type'] = self.plan_df['unsteady_number'].apply(
+                    lambda x: 'Unsteady' if pd.notna(x) else 'Steady'
+                )
+            else:
+                if not self.plan_df.empty:
+                    self.plan_df['flow_type'] = 'Unknown'
+
         except Exception as e:
             logger.error(f"Error loading project data: {e}")
             raise
@@ -1265,13 +1288,18 @@ def init_ras_project(ras_project_folder, ras_version=None, ras_object=None):
     Initialize a RAS project for use with the ras-commander library.
 
     This is the primary function for setting up a HEC-RAS project. It:
-    1. Finds the project file (.prj) in the specified folder
-    2. Identifies the appropriate HEC-RAS executable
-    3. Loads project data (plans, geometries, flows)
-    4. Creates dataframes containing project components
+    1. Finds the project file (.prj) in the specified folder OR uses the provided .prj file
+    2. Validates .prj files by checking for "Proj Title=" marker
+    3. Identifies the appropriate HEC-RAS executable
+    4. Loads project data (plans, geometries, flows)
+    5. Creates dataframes containing project components
 
     Args:
-        ras_project_folder (str or Path): The path to the RAS project folder.
+        ras_project_folder (str or Path): Path to the RAS project folder OR direct path to a .prj file.
+                                          If a .prj file is provided:
+                                          - File is validated to have .prj extension
+                                          - File content is checked for "Proj Title=" marker
+                                          - Parent folder is used as the project folder
         ras_version (str, optional): The version of RAS to use (e.g., "6.6") OR
                                      a full path to the Ras.exe file (e.g., "D:/Programs/HEC/HEC-RAS/6.6/Ras.exe").
                                      If None, will attempt to detect from plan files.
@@ -1281,25 +1309,71 @@ def init_ras_project(ras_project_folder, ras_version=None, ras_object=None):
 
     Returns:
         RasPrj: An initialized RasPrj instance.
-        
+
     Raises:
-        FileNotFoundError: If the specified project folder doesn't exist.
-        ValueError: If no HEC-RAS project file is found in the folder.
-        
+        FileNotFoundError: If the specified project folder or .prj file doesn't exist.
+        ValueError: If the provided file is not a .prj file, does not contain "Proj Title=",
+                    or if no HEC-RAS project file is found in the folder.
+
     Example:
-        >>> # Initialize using the global 'ras' object (most common)
+        >>> # Initialize using project folder (existing behavior)
         >>> init_ras_project("/path/to/project", "6.6")
         >>> print(f"Initialized project: {ras.project_name}")
         >>>
-        >>> # Create a new RasPrj instance
-        >>> my_project = init_ras_project("/path/to/project", "6.6", "new")
+        >>> # Initialize using direct .prj file path (new feature)
+        >>> init_ras_project("/path/to/project/MyModel.prj", "6.6")
+        >>> print(f"Initialized project: {ras.project_name}")
+        >>>
+        >>> # Create a new RasPrj instance with .prj file
+        >>> my_project = init_ras_project("/path/to/project/MyModel.prj", "6.6", "new")
         >>> print(f"Created project instance: {my_project.project_name}")
     """
-    # Convert to absolute path immediately to ensure consistent path handling
-    project_folder = Path(ras_project_folder).resolve()
-    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.")
+    # Convert to Path object for consistent handling
+    input_path = Path(ras_project_folder).resolve()
+
+    # Detect if input is a file or folder
+    if input_path.is_file():
+        # User provided a .prj file path
+        if input_path.suffix.lower() != '.prj':
+            error_msg = f"The provided file is not a HEC-RAS project file (.prj): {input_path}"
+            logger.error(error_msg)
+            raise ValueError(f"{error_msg}. Please provide either a project folder or a .prj file.")
+
+        # Enhanced validation: Check if file contains "Proj Title=" to verify it's a HEC-RAS project file
+        try:
+            content, encoding = read_file_with_fallback_encoding(input_path)
+            if content is None or "Proj Title=" not in content:
+                error_msg = f"The file does not appear to be a valid HEC-RAS project file (missing 'Proj Title='): {input_path}"
+                logger.error(error_msg)
+                raise ValueError(f"{error_msg}. Please provide a valid HEC-RAS .prj file.")
+            logger.debug(f"Validated .prj file contains 'Proj Title=' marker")
+        except Exception as e:
+            error_msg = f"Error validating .prj file: {e}"
+            logger.error(error_msg)
+            raise ValueError(f"{error_msg}. Please ensure the file is a valid HEC-RAS project file.")
+
+        # Extract the parent folder to use as project_folder
+        project_folder = input_path.parent
+        specified_prj_file = input_path  # Store for optimization
+        logger.debug(f"User provided .prj file: {input_path}")
+        logger.debug(f"Using parent folder as project_folder: {project_folder}")
+
+    elif input_path.is_dir():
+        # User provided a folder path (existing behavior)
+        project_folder = input_path
+        specified_prj_file = None
+        logger.debug(f"User provided folder path: {project_folder}")
+
+    else:
+        # Path doesn't exist
+        if input_path.suffix.lower() == '.prj':
+            error_msg = f"The specified .prj file does not exist: {input_path}"
+            logger.error(error_msg)
+            raise FileNotFoundError(f"{error_msg}. Please check the path and try again.")
+        else:
+            error_msg = f"The specified RAS project folder does not exist: {input_path}"
+            logger.error(error_msg)
+            raise FileNotFoundError(f"{error_msg}. Please check the path and try again.")
 
     # Determine which RasPrj instance to use
     if ras_object is None:
@@ -1372,13 +1446,20 @@ def init_ras_project(ras_project_folder, ras_version=None, ras_object=None):
             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)
-    
+    # Pass specified_prj_file to avoid re-searching when user provided .prj file directly
+    if specified_prj_file is not None:
+        ras_object.initialize(project_folder, ras_exe_path, prj_file=specified_prj_file)
+    else:
+        ras_object.initialize(project_folder, ras_exe_path)
+
     # Always update the global ras object as well
     if ras_object is not ras:
-        ras.initialize(project_folder, ras_exe_path)
+        if specified_prj_file is not None:
+            ras.initialize(project_folder, ras_exe_path, prj_file=specified_prj_file)
+        else:
+            ras.initialize(project_folder, ras_exe_path)
         logger.debug("Global 'ras' object also updated to match the new project.")
-    
+
     logger.debug(f"Project initialized. Project folder: {ras_object.project_folder}")
     logger.debug(f"Using HEC-RAS executable: {ras_exe_path}")
     return ras_object

ras_commander/__init__.py

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

{ras_commander-0.80.2.dist-info → ras_commander-0.81.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ras-commander
-Version: 0.80.2
+Version: 0.81.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.80.2.dist-info → ras_commander-0.81.0.dist-info}/RECORD

@@ -9,7 +9,7 @@ ras_commander/HdfPlan.py,sha256=WINI3lp865cE99QXztgvKKIhVUTOqu4X41ZPBfhYJGU,1214
 ras_commander/HdfPlot.py,sha256=7MNI5T9qIz-Ava1RdlnB6O9oJElE5BEB29QVF5Y2Xuc,3401
 ras_commander/HdfPump.py,sha256=Vc2ff16kRISR7jwtnaAqxI0p-gfBSuZKzR3rQbBLQoE,12951
 ras_commander/HdfResultsMesh.py,sha256=FIUN_yZ6h1XrcaHuOdAQrozOBN_UKNNn3_l8lO703dk,44172
-ras_commander/HdfResultsPlan.py,sha256=gmeAceYHABubv0V8dJL2F5GN4Th7g92E_1y-Hc4JZjg,16626
+ras_commander/HdfResultsPlan.py,sha256=wsIUTyBFowJXeNwMsX0cZ00srqJDEwx5wENPpJLzatw,31479
 ras_commander/HdfResultsPlot.py,sha256=ylzfT78CfgoDO0XAlRwlgMNRzvNQYBMn9eyXyBfjv_w,7660
 ras_commander/HdfResultsXsec.py,sha256=-P7nXnbjOLAeUnrdSC_lJQSfzrlWKmDF9Z5gEjmxbJY,13031
 ras_commander/HdfStruc.py,sha256=SznjPvBWiqNVtviZvfCdjB_iwZF4UXxlIxITD8kwjP4,13733
@@ -21,12 +21,12 @@ ras_commander/RasExamples.py,sha256=QFWnWnxACpQzewzA3QFMp4z4iEkg5PWf9cPDdMay7MA,
 ras_commander/RasGeo.py,sha256=Wy5N1yP7_St3cA3ENJliojQ2sb2w2dL8Fy8L_sZsykc,22208
 ras_commander/RasMap.py,sha256=20db61KkUz2CgjfCCYY8F-IYy5doHOtdnTKChiK0ENs,20257
 ras_commander/RasPlan.py,sha256=ogIpLqawXTsjLnKRZTqzZydn_EFVJZFZZGgHvJ_t_-c,65408
-ras_commander/RasPrj.py,sha256=oXPWuNC_403mUfqyysXyBVul0Xtz_0SKDxZdj4fvNYU,63448
+ras_commander/RasPrj.py,sha256=30y6kJ4jcfX7dE2BB5w7KHIHP1vUVlfB-YWM0xBNhbg,68031
 ras_commander/RasUnsteady.py,sha256=PdQQMiY7Mz1EsOQk6ygFQtlC2sFEa96Ntg-pznWVpLQ,37187
 ras_commander/RasUtils.py,sha256=0fm4IIs0LH1dgDj3pGd66mR82DhWLEkRKUvIo2M_5X0,35886
-ras_commander/__init__.py,sha256=h27KNGTejtJoQ-Fk8rC7KmLiZx2IKAMyXRts7zuGw-w,2039
-ras_commander-0.80.2.dist-info/licenses/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
-ras_commander-0.80.2.dist-info/METADATA,sha256=cQIheuTvKMWe1sVNecRfyCK0b9j4hBjKjBgpisnRKII,27941
-ras_commander-0.80.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ras_commander-0.80.2.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
-ras_commander-0.80.2.dist-info/RECORD,,
+ras_commander/__init__.py,sha256=cceh-WJ7RMhQjPUH7ztMO5sWZDUx5jMsOEtrnOPMYMU,2039
+ras_commander-0.81.0.dist-info/licenses/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
+ras_commander-0.81.0.dist-info/METADATA,sha256=pwshM3miZgeD-5tQAZaBLUb-HKzw5gaCM06OCFrkTgE,27941
+ras_commander-0.81.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ras_commander-0.81.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
+ras_commander-0.81.0.dist-info/RECORD,,