ras-commander 0.80.2__tar.gz → 0.81.0__tar.gz

{ras_commander-0.80.2/ras_commander.egg-info → ras_commander-0.81.0}/PKG-INFO

@@ -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 → ras_commander-0.81.0}/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-0.80.2 → ras_commander-0.81.0}/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-0.80.2 → ras_commander-0.81.0}/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 → ras_commander-0.81.0/ras_commander.egg-info}/PKG-INFO

@@ -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 → ras_commander-0.81.0}/ras_commander.egg-info/SOURCES.txt

@@ -33,5 +33,4 @@ ras_commander.egg-info/PKG-INFO
 ras_commander.egg-info/SOURCES.txt
 ras_commander.egg-info/dependency_links.txt
 ras_commander.egg-info/requires.txt
-ras_commander.egg-info/top_level.txt
-tests/test_ras_examples_initialization.py
+ras_commander.egg-info/top_level.txt

{ras_commander-0.80.2 → ras_commander-0.81.0}/setup.py

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

ras_commander-0.80.2/tests/test_ras_examples_initialization.py

@@ -1,241 +0,0 @@
-"""
-Test script to verify RasExamples project extraction and initialization.
-
-This script extracts multiple HEC-RAS example projects and attempts to initialize them
-to check for any errors in the extraction or initialization process.
-"""
-
-import os
-import sys
-import tempfile
-import shutil
-from pathlib import Path
-from datetime import datetime
-
-# Add parent directory to path to import ras_commander
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from ras_commander import RasExamples, init_ras_project, RasPrj
-
-# List of projects to test
-PROJECTS_TO_TEST = [
-    'BSTEM - Simple Example',
-    'Dredging Example',
-    'Reservoir Video Tutorial',
-    'SIAM Example',
-    'Simple Sediment Transport Example',
-    'Unsteady Sediment with Concentration Rules',
-    'Video Tutorial (Sediment Intro)',
-    'Baxter RAS Mapper',
-    'Chapter 4 Example Data',
-    'ConSpan Culvert',
-    'Mixed Flow Regime Channel',
-    'Wailupe GeoRAS',
-    'Balde Eagle Creek',
-    'Bridge Hydraulics',
-    'ContractionExpansionMinorLosses',
-    'Culvert Hydraulics',
-    'Culverts with Flap Gates',
-    'Dam Breaching',
-    'Elevation Controled Gates',
-    'Inline Structure with Gated Spillways',
-    'Internal Stage and Flow Boundary Condition',
-    'JunctionHydraulics',
-    'Lateral Strcuture with Gates',
-    'Lateral Structure connected to a River Reach',
-    'Lateral Structure Overflow Weir',
-    'Lateral Structure with Culverts and Gates',
-    'Lateral Structure with Culverts',
-    'Levee Breaching',
-    'Mixed Flow Regime',
-    'Multiple Reaches with Hydraulic Structures',
-    'NavigationDam',
-    'Pumping Station with Rules',
-    'Pumping Station',
-    'Rule Operations',
-    'Simplified Physical Breaching',
-    'Storage Area Hydraulic Connection',
-    'UngagedAreaInflows',
-    'Unsteady Flow Encroachment Analysis',
-    'Chippewa_2D',
-    'Weise_2D',
-    'BaldEagleCrkMulti2D',
-    'Muncie',
-    'Example 1 - Critical Creek',
-    'Example 10 - Stream Junction',
-    'Example 11 - Bridge Scour',
-    'Example 12 - Inline Structure',
-    'Example 13 - Singler Bridge (WSPRO)',
-    'Example 14 - Ice Covered River',
-    'Example 15 - Split Flow Junction with Lateral Weir',
-    'Example 16 - Channel Modification',
-    'Example 17 - Unsteady Flow Application',
-    'Example 18 - Advanced Inline Structure',
-    'Example 19 - Hydrologic Routing - ModPuls',
-    'Example 2 - Beaver Creek',
-    'Example 20 - HagerLatWeir',
-    'Example 21 - Overflow Gates',
-    'Example 22 - Groundwater Interflow',
-    'Example 23 - Urban Modeling',
-    'Example 24 - Mannings-n-Calibration',
-    'Example 3 - Single Culvert',
-    'Example 4 - Multiple Culverts',
-    'Example 5 - Multiple Openings',
-    'Example 6 - Floodway Determination',
-    'Example 7 - Multiple Plans',
-    'Example 8 - Looped Network',
-    'Example 9 - Mixed Flow Analysis',
-    'Davis',
-    'Nutrient Example',
-    'NewOrleansMetro',
-    'BeaverLake'
-]
-
-
-def test_project_extraction_and_initialization():
-    """Test extraction and initialization of RAS example projects."""
-    
-    # Save current directory
-    original_dir = os.getcwd()
-    
-    # Change to parent directory if we're in the tests folder
-    if os.path.basename(os.getcwd()) == 'tests':
-        os.chdir('..')
-        print(f"Changed to parent directory: {os.getcwd()}")
-    
-    # Results tracking
-    results = {
-        'successful': [],
-        'extraction_failed': [],
-        'initialization_failed': [],
-        'errors': {}
-    }
-    
-    total_projects = len(PROJECTS_TO_TEST)
-    
-    print(f"Testing {total_projects} HEC-RAS example projects...")
-    print(f"Projects will be extracted to: {os.path.join(os.getcwd(), 'example_projects')}")
-    
-    for i, project_name in enumerate(PROJECTS_TO_TEST, 1):
-        print(f"\n[{i}/{total_projects}] Testing project: {project_name}")
-        print("-" * 60)
-        
-        try:
-            # Extract the project (RasExamples handles destination automatically)
-            print(f"  Extracting project...")
-            extraction_path = RasExamples.extract_project(project_name)
-            
-            if not extraction_path:
-                print(f"  [FAILED] Extraction failed: No path returned")
-                results['extraction_failed'].append(project_name)
-                continue
-                
-            print(f"  [SUCCESS] Extracted to: {extraction_path}")
-            
-            # Try to initialize the project
-            print(f"  Initializing project...")
-            try:
-                # Create a custom RasPrj object for this project
-                ras_project = RasPrj()
-                init_ras_project(extraction_path, ras_version="6.6", ras_object=ras_project)
-                
-                if ras_project:
-                    # Debug what attributes the object has
-                    attrs = [attr for attr in dir(ras_project) if not attr.startswith('_')]
-                    print(f"  Debug - RasPrj attributes: {', '.join(attrs[:10])}...")
-                    
-                    # Check for common attributes
-                    if hasattr(ras_project, 'prj_file') and ras_project.prj_file is not None:
-                        print(f"  [SUCCESS] Successfully initialized")
-                        print(f"    - Project file: {ras_project.prj_file}")
-                        print(f"    - Project name: {ras_project.project_name if hasattr(ras_project, 'project_name') else 'N/A'}")
-                        print(f"    - Version: {ras_project.version if hasattr(ras_project, 'version') else 'N/A'}")
-                        print(f"    - Plans: {len(ras_project.plan_df) if hasattr(ras_project, 'plan_df') else 0} found")
-                        print(f"    - Geometries: {len(ras_project.geom_df) if hasattr(ras_project, 'geom_df') else 0} found")
-                        results['successful'].append(project_name)
-                    else:
-                        print(f"  [FAILED] Object missing prj_file attribute or it's None")
-                        results['initialization_failed'].append(project_name)
-                else:
-                    print(f"  [FAILED] Initialization returned None")
-                    results['initialization_failed'].append(project_name)
-                    
-            except Exception as init_error:
-                print(f"  [FAILED] Initialization error: {str(init_error)}")
-                results['initialization_failed'].append(project_name)
-                results['errors'][project_name] = {
-                    'stage': 'initialization',
-                    'error': str(init_error)
-                }
-                
-        except Exception as extract_error:
-            print(f"  [FAILED] Extraction error: {str(extract_error)}")
-            results['extraction_failed'].append(project_name)
-            results['errors'][project_name] = {
-                'stage': 'extraction',
-                'error': str(extract_error)
-            }
-    
-    # Print summary
-    print("\n" + "=" * 80)
-    print("TEST SUMMARY")
-    print("=" * 80)
-    print(f"Total projects tested: {total_projects}")
-    print(f"[SUCCESS] Successful: {len(results['successful'])}")
-    print(f"[FAILED] Extraction failed: {len(results['extraction_failed'])}")
-    print(f"[FAILED] Initialization failed: {len(results['initialization_failed'])}")
-    
-    if results['extraction_failed']:
-        print(f"\nExtraction Failed Projects:")
-        for proj in results['extraction_failed']:
-            print(f"  - {proj}")
-            if proj in results['errors']:
-                print(f"    Error: {results['errors'][proj]['error']}")
-    
-    if results['initialization_failed']:
-        print(f"\nInitialization Failed Projects:")
-        for proj in results['initialization_failed']:
-            print(f"  - {proj}")
-            if proj in results['errors']:
-                print(f"    Error: {results['errors'][proj]['error']}")
-    
-    # Write detailed results to file
-    results_file = f"test_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
-    with open(results_file, 'w') as f:
-        f.write("RAS Examples Test Results\n")
-        f.write("=" * 80 + "\n")
-        f.write(f"Test Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
-        f.write(f"Total Projects: {total_projects}\n")
-        f.write(f"Successful: {len(results['successful'])}\n")
-        f.write(f"Extraction Failed: {len(results['extraction_failed'])}\n")
-        f.write(f"Initialization Failed: {len(results['initialization_failed'])}\n")
-        f.write("\n" + "=" * 80 + "\n")
-        
-        f.write("\nSUCCESSFUL PROJECTS:\n")
-        for proj in results['successful']:
-            f.write(f"  - {proj}\n")
-        
-        f.write("\nEXTRACTION FAILED:\n")
-        for proj in results['extraction_failed']:
-            f.write(f"  - {proj}\n")
-            if proj in results['errors']:
-                f.write(f"    Error: {results['errors'][proj]['error']}\n")
-        
-        f.write("\nINITIALIZATION FAILED:\n")
-        for proj in results['initialization_failed']:
-            f.write(f"  - {proj}\n")
-            if proj in results['errors']:
-                f.write(f"    Error: {results['errors'][proj]['error']}\n")
-    
-    print(f"\nDetailed results written to: {results_file}")
-    
-    # Restore original directory
-    os.chdir(original_dir)
-    
-    return results
-
-
-if __name__ == "__main__":
-    print("Starting RAS Examples Initialization Test")
-    print("=" * 80)
-    results = test_project_extraction_and_initialization()