ras-commander 0.77.0__tar.gz → 0.79.0__tar.gz

{ras_commander-0.77.0/ras_commander.egg-info → ras_commander-0.79.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ras-commander
-Version: 0.77.0
+Version: 0.79.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.
@@ -291,7 +291,7 @@ This is useful for comparing different river systems, running scenario analyses
 - `RasGeo`: Handles operations related to geometry files
 - `RasUnsteady`: Manages unsteady flow file operations
 - `RasUtils`: Contains utility functions for file operations and data management
-- `RasMap`: Parses and manages RASMapper configuration data
+- `RasMap`: Parses RASMapper configuration files and automates floodplain mapping
 - `RasExamples`: Manages and loads HEC-RAS example projects
 
 #### HDF Data Access Classes
@@ -511,7 +511,6 @@ Additionally, we would like to acknowledge the following notable contributions a
 
 - Development of additional HDF functions for detailed analysis and mapping of HEC-RAS results within the RasHdf class.
 - Development of the prototype `RasCmdr` class for executing HEC-RAS simulations.
-- Optimization examples and methods from (INSERT REFERENCE) for use in the Ras-Commander library examples
 
 2. Attribution: The [`pyHMT2D`](https://github.com/psu-efd/pyHMT2D/) project by Xiaofeng Liu, which provided insights into HDF file handling methods for HEC-RAS outputs.  Many of the functions in the [Ras_2D_Data.py](https://github.com/psu-efd/pyHMT2D/blob/main/pyHMT2D/Hydraulic_Models_Data/RAS_2D/RAS_2D_Data.py) file were adapted with AI for use in RAS Commander. 
 

{ras_commander-0.77.0 → ras_commander-0.79.0}/README.md

@@ -258,7 +258,7 @@ This is useful for comparing different river systems, running scenario analyses
 - `RasGeo`: Handles operations related to geometry files
 - `RasUnsteady`: Manages unsteady flow file operations
 - `RasUtils`: Contains utility functions for file operations and data management
-- `RasMap`: Parses and manages RASMapper configuration data
+- `RasMap`: Parses RASMapper configuration files and automates floodplain mapping
 - `RasExamples`: Manages and loads HEC-RAS example projects
 
 #### HDF Data Access Classes
@@ -478,7 +478,6 @@ Additionally, we would like to acknowledge the following notable contributions a
 
 - Development of additional HDF functions for detailed analysis and mapping of HEC-RAS results within the RasHdf class.
 - Development of the prototype `RasCmdr` class for executing HEC-RAS simulations.
-- Optimization examples and methods from (INSERT REFERENCE) for use in the Ras-Commander library examples
 
 2. Attribution: The [`pyHMT2D`](https://github.com/psu-efd/pyHMT2D/) project by Xiaofeng Liu, which provided insights into HDF file handling methods for HEC-RAS outputs.  Many of the functions in the [Ras_2D_Data.py](https://github.com/psu-efd/pyHMT2D/blob/main/pyHMT2D/Hydraulic_Models_Data/RAS_2D/RAS_2D_Data.py) file were adapted with AI for use in RAS Commander. 
 

ras_commander-0.79.0/ras_commander/HdfFluvialPluvial.py

@@ -0,0 +1,416 @@
+"""
+Class: HdfFluvialPluvial
+
+All of the methods in this class are static and are designed to be used without instantiation.
+
+List of Functions in HdfFluvialPluvial:
+- calculate_fluvial_pluvial_boundary(): Returns LineStrings representing the boundary.
+- generate_fluvial_pluvial_polygons(): Returns dissolved Polygons for fluvial, pluvial, and ambiguous zones.
+- _process_cell_adjacencies()
+- _get_boundary_cell_pairs()
+- _identify_boundary_edges()
+
+"""
+
+from typing import Dict, List, Tuple, Set, Optional
+import pandas as pd
+import geopandas as gpd
+from collections import defaultdict
+from shapely.geometry import LineString, MultiLineString
+from tqdm import tqdm
+from .HdfMesh import HdfMesh
+from .HdfUtils import HdfUtils
+from .Decorators import standardize_input
+from .HdfResultsMesh import HdfResultsMesh
+from .LoggingConfig import get_logger
+from pathlib import Path
+
+logger = get_logger(__name__)
+
+class HdfFluvialPluvial:
+    """
+    A class for analyzing and visualizing fluvial-pluvial boundaries in HEC-RAS 2D model results.
+
+    This class provides methods to process and visualize HEC-RAS 2D model outputs,
+    specifically focusing on the delineation of fluvial and pluvial flood areas.
+    It includes functionality for calculating fluvial-pluvial boundaries based on
+    the timing of maximum water surface elevations.
+
+    Key Concepts:
+    - Fluvial flooding: Flooding from rivers/streams
+    - Pluvial flooding: Flooding from rainfall/surface water
+    - delta_t: Time threshold (in hours) used to distinguish between fluvial and pluvial cells.
+               Cells with max WSE time differences greater than delta_t are considered boundaries.
+
+    Data Requirements:
+    - HEC-RAS plan HDF file containing:
+        - 2D mesh cell geometry (accessed via HdfMesh)
+        - Maximum water surface elevation times (accessed via HdfResultsMesh)
+
+    Usage Example:
+        >>> from ras_commander import HdfFluvialPluvial
+        >>> hdf_path = Path("path/to/plan.hdf")
+        
+        # To get just the boundary lines
+        >>> boundary_lines_gdf = HdfFluvialPluvial.calculate_fluvial_pluvial_boundary(
+        ...     hdf_path, 
+        ...     delta_t=12
+        ... )
+        
+        # To get classified flood polygons
+        >>> flood_polygons_gdf = HdfFluvialPluvial.generate_fluvial_pluvial_polygons(
+        ...     hdf_path,
+        ...     delta_t=12,
+        ...     temporal_tolerance_hours=1.0
+        ... )
+    """
+    def __init__(self):
+        self.logger = get_logger(__name__)  # Initialize logger with module name
+    
+    @staticmethod
+    @standardize_input(file_type='plan_hdf')
+    def calculate_fluvial_pluvial_boundary(
+        hdf_path: Path, 
+        delta_t: float = 12,
+        min_line_length: Optional[float] = None
+    ) -> gpd.GeoDataFrame:
+        """
+        Calculate the fluvial-pluvial boundary lines based on cell polygons and maximum water surface elevation times.
+
+        This function is useful for visualizing the line of transition between flooding mechanisms.
+
+        Args:
+            hdf_path (Path): Path to the HEC-RAS plan HDF file.
+            delta_t (float): Threshold time difference in hours. Cells with time differences
+                             greater than this value are considered boundaries. Default is 12 hours.
+            min_line_length (float, optional): Minimum length (in CRS units) for boundary lines to be included.
+                                               Lines shorter than this will be dropped. Default is None (no filtering).
+
+        Returns:
+            gpd.GeoDataFrame: GeoDataFrame containing the fluvial-pluvial boundary lines.
+        """
+        try:
+            logger.info("Getting cell polygons from HDF file...")
+            cell_polygons_gdf = HdfMesh.get_mesh_cell_polygons(hdf_path)
+            if cell_polygons_gdf.empty:
+                raise ValueError("No cell polygons found in HDF file")
+
+            logger.info("Getting maximum water surface data from HDF file...")
+            max_ws_df = HdfResultsMesh.get_mesh_max_ws(hdf_path)
+            if max_ws_df.empty:
+                raise ValueError("No maximum water surface data found in HDF file")
+
+            logger.info("Converting maximum water surface timestamps...")
+            max_ws_df['maximum_water_surface_time'] = max_ws_df['maximum_water_surface_time'].apply(
+                lambda x: HdfUtils.parse_ras_datetime(x) if isinstance(x, str) else x
+            )
+
+            logger.info("Processing cell adjacencies...")
+            cell_adjacency, common_edges = HdfFluvialPluvial._process_cell_adjacencies(cell_polygons_gdf)
+            
+            logger.info("Extracting cell times from maximum water surface data...")
+            cell_times = max_ws_df.set_index('cell_id')['maximum_water_surface_time'].to_dict()
+            
+            logger.info("Identifying boundary edges...")
+            boundary_edges = HdfFluvialPluvial._identify_boundary_edges(
+                cell_adjacency, common_edges, cell_times, delta_t, min_line_length=min_line_length
+            )
+
+            logger.info("Creating final GeoDataFrame for boundaries...")
+            boundary_gdf = gpd.GeoDataFrame(
+                geometry=boundary_edges, 
+                crs=cell_polygons_gdf.crs
+            )
+
+            logger.info("Boundary line calculation completed successfully.")
+            return boundary_gdf
+
+        except Exception as e:
+            logger.error(f"Error calculating fluvial-pluvial boundary lines: {str(e)}")
+            return gpd.GeoDataFrame()
+
+    @staticmethod
+    @standardize_input(file_type='plan_hdf')
+    def generate_fluvial_pluvial_polygons(
+        hdf_path: Path, 
+        delta_t: float = 12, 
+        temporal_tolerance_hours: float = 1.0,
+        min_polygon_area_acres: Optional[float] = None
+    ) -> gpd.GeoDataFrame:
+        """
+        Generates dissolved polygons representing fluvial, pluvial, and ambiguous flood zones.
+
+        This function classifies each wetted cell and merges them into three distinct regions
+        based on the timing of maximum water surface elevation.
+
+        Optionally, for polygons classified as fluvial or pluvial, if their area is less than
+        min_polygon_area_acres, they are reclassified to the opposite type and merged with
+        adjacent polygons of that type. Ambiguous polygons are exempt from this logic.
+
+        Args:
+            hdf_path (Path): Path to the HEC-RAS plan HDF file.
+            delta_t (float): The time difference (in hours) between adjacent cells that defines
+                             the initial boundary between fluvial and pluvial zones. Default is 12.
+            temporal_tolerance_hours (float): The maximum time difference (in hours) for a cell
+                                              to be considered part of an expanding region. 
+                                              Default is 1.0.
+            min_polygon_area_acres (float, optional): Minimum polygon area (in acres). For fluvial or pluvial
+                                                      polygons smaller than this, reclassify to the opposite
+                                                      type and merge with adjacent polygons of that type.
+                                                      Ambiguous polygons are not affected.
+
+        Returns:
+            gpd.GeoDataFrame: A GeoDataFrame with dissolved polygons for 'fluvial', 'pluvial',
+                              and 'ambiguous' zones.
+        """
+        try:
+            # --- 1. Data Loading and Preparation ---
+            logger.info("Loading mesh and results data...")
+            cell_polygons_gdf = HdfMesh.get_mesh_cell_polygons(hdf_path)
+            max_ws_df = HdfResultsMesh.get_mesh_max_ws(hdf_path)
+            max_ws_df['maximum_water_surface_time'] = max_ws_df['maximum_water_surface_time'].apply(
+                lambda x: HdfUtils.parse_ras_datetime(x) if isinstance(x, str) else x
+            )
+            cell_times = max_ws_df.set_index('cell_id')['maximum_water_surface_time'].to_dict()
+            
+            logger.info("Processing cell adjacencies...")
+            cell_adjacency, _ = HdfFluvialPluvial._process_cell_adjacencies(cell_polygons_gdf)
+
+            # --- 2. Seeding the Classifications ---
+            logger.info(f"Identifying initial boundary seeds with delta_t = {delta_t} hours...")
+            boundary_pairs = HdfFluvialPluvial._get_boundary_cell_pairs(cell_adjacency, cell_times, delta_t)
+
+            classifications = pd.Series('unclassified', index=cell_polygons_gdf['cell_id'], name='classification')
+            
+            for cell1, cell2 in boundary_pairs:
+                if cell_times.get(cell1) > cell_times.get(cell2):
+                    classifications.loc[cell1] = 'fluvial'
+                    classifications.loc[cell2] = 'pluvial'
+                else:
+                    classifications.loc[cell1] = 'pluvial'
+                    classifications.loc[cell2] = 'fluvial'
+            
+            # --- 3. Iterative Region Growth ---
+            logger.info(f"Starting iterative region growth with tolerance = {temporal_tolerance_hours} hours...")
+            fluvial_frontier = set(classifications[classifications == 'fluvial'].index)
+            pluvial_frontier = set(classifications[classifications == 'pluvial'].index)
+            
+            iteration = 0
+            with tqdm(desc="Region Growing", unit="iter") as pbar:
+                while fluvial_frontier or pluvial_frontier:
+                    iteration += 1
+                    
+                    next_fluvial_candidates = set()
+                    for cell_id in fluvial_frontier:
+                        for neighbor_id in cell_adjacency.get(cell_id, []):
+                            if classifications.loc[neighbor_id] == 'unclassified' and pd.notna(cell_times.get(neighbor_id)):
+                                time_diff_seconds = abs((cell_times[cell_id] - cell_times[neighbor_id]).total_seconds())
+                                if time_diff_seconds <= temporal_tolerance_hours * 3600:
+                                    next_fluvial_candidates.add(neighbor_id)
+                    
+                    next_pluvial_candidates = set()
+                    for cell_id in pluvial_frontier:
+                        for neighbor_id in cell_adjacency.get(cell_id, []):
+                            if classifications.loc[neighbor_id] == 'unclassified' and pd.notna(cell_times.get(neighbor_id)):
+                                time_diff_seconds = abs((cell_times[cell_id] - cell_times[neighbor_id]).total_seconds())
+                                if time_diff_seconds <= temporal_tolerance_hours * 3600:
+                                    next_pluvial_candidates.add(neighbor_id)
+                    
+                    # Resolve conflicts
+                    ambiguous_cells = next_fluvial_candidates.intersection(next_pluvial_candidates)
+                    if ambiguous_cells:
+                        classifications.loc[list(ambiguous_cells)] = 'ambiguous'
+                        
+                    # Classify non-conflicted cells
+                    newly_fluvial = next_fluvial_candidates - ambiguous_cells
+                    if newly_fluvial:
+                        classifications.loc[list(newly_fluvial)] = 'fluvial'
+
+                    newly_pluvial = next_pluvial_candidates - ambiguous_cells
+                    if newly_pluvial:
+                        classifications.loc[list(newly_pluvial)] = 'pluvial'
+                    
+                    # Update frontiers for the next iteration
+                    fluvial_frontier = newly_fluvial
+                    pluvial_frontier = newly_pluvial
+                                        
+                    pbar.update(1)
+                    pbar.set_postfix({
+                        "Fluvial": len(fluvial_frontier), 
+                        "Pluvial": len(pluvial_frontier),
+                        "Ambiguous": len(ambiguous_cells)
+                    })
+            
+            logger.info(f"Region growing completed in {iteration} iterations.")
+            
+            # --- 4. Finalization and Dissolving ---
+            # Classify any remaining unclassified (likely isolated) cells as ambiguous
+            classifications[classifications == 'unclassified'] = 'ambiguous'
+
+            logger.info("Merging classifications with cell polygons...")
+            classified_gdf = cell_polygons_gdf.merge(classifications.to_frame(), left_on='cell_id', right_index=True)
+            
+            logger.info("Dissolving polygons by classification...")
+            final_regions_gdf = classified_gdf.dissolve(by='classification', aggfunc='first').reset_index()
+
+            # --- 5. Minimum Polygon Area Filtering and Merging (if requested) ---
+            if min_polygon_area_acres is not None:
+                logger.info(f"Applying minimum polygon area filter: {min_polygon_area_acres} acres")
+                # Calculate area in acres (1 acre = 4046.8564224 m^2)
+                # If CRS is not projected, warn and skip area filtering
+                if not final_regions_gdf.crs or not final_regions_gdf.crs.is_projected:
+                    logger.warning("CRS is not projected. Area-based filtering skipped.")
+                else:
+                    # Explode to individual polygons for area filtering
+                    exploded = final_regions_gdf.explode(index_parts=False, ignore_index=True)
+                    exploded['area_acres'] = exploded.geometry.area / 4046.8564224
+
+                    # Only consider fluvial and pluvial polygons for area filtering
+                    mask_fluvial = (exploded['classification'] == 'fluvial') & (exploded['area_acres'] < min_polygon_area_acres)
+                    mask_pluvial = (exploded['classification'] == 'pluvial') & (exploded['area_acres'] < min_polygon_area_acres)
+
+                    n_fluvial = mask_fluvial.sum()
+                    n_pluvial = mask_pluvial.sum()
+                    logger.info(f"Found {n_fluvial} small fluvial and {n_pluvial} small pluvial polygons to reclassify.")
+
+                    # Reclassify small fluvial polygons as pluvial, and small pluvial polygons as fluvial
+                    exploded.loc[mask_fluvial, 'classification'] = 'pluvial'
+                    exploded.loc[mask_pluvial, 'classification'] = 'fluvial'
+                    # Ambiguous polygons are not changed
+
+                    # Redissolve by classification to merge with adjacent polygons of the same type
+                    final_regions_gdf = exploded.dissolve(by='classification', aggfunc='first').reset_index()
+                    logger.info("Redissolved polygons after reclassification of small areas.")
+
+            logger.info("Polygon generation completed successfully.")
+            return final_regions_gdf
+            
+        except Exception as e:
+            logger.error(f"Error generating fluvial-pluvial polygons: {str(e)}", exc_info=True)
+            return gpd.GeoDataFrame()
+        
+        
+    @staticmethod
+    def _process_cell_adjacencies(cell_polygons_gdf: gpd.GeoDataFrame) -> Tuple[Dict[int, List[int]], Dict[int, Dict[int, LineString]]]:
+        """
+        Optimized method to process cell adjacencies by extracting shared edges directly.
+        """
+        cell_adjacency = defaultdict(list)
+        common_edges = defaultdict(dict)
+        edge_to_cells = defaultdict(set)
+
+        def edge_key(coords1, coords2, precision=8):
+            coords1 = tuple(round(coord, precision) for coord in coords1)
+            coords2 = tuple(round(coord, precision) for coord in coords2)
+            return tuple(sorted([coords1, coords2]))
+
+        for _, row in cell_polygons_gdf.iterrows():
+            cell_id = row['cell_id']
+            geom = row['geometry']
+            if geom.is_empty or not geom.is_valid:
+                continue
+            coords = list(geom.exterior.coords)
+            for i in range(len(coords) - 1):
+                key = edge_key(coords[i], coords[i + 1])
+                edge_to_cells[key].add(cell_id)
+
+        for edge, cells in edge_to_cells.items():
+            cell_list = list(cells)
+            if len(cell_list) >= 2:
+                for i in range(len(cell_list)):
+                    for j in range(i + 1, len(cell_list)):
+                        cell1, cell2 = cell_list[i], cell_list[j]
+                        cell_adjacency[cell1].append(cell2)
+                        cell_adjacency[cell2].append(cell1)
+                        common_edge = LineString([edge[0], edge[1]])
+                        common_edges[cell1][cell2] = common_edge
+                        common_edges[cell2][cell1] = common_edge
+
+        return cell_adjacency, common_edges
+    
+    @staticmethod
+    def _get_boundary_cell_pairs(
+        cell_adjacency: Dict[int, List[int]], 
+        cell_times: Dict[int, pd.Timestamp], 
+        delta_t: float
+    ) -> List[Tuple[int, int]]:
+        """
+        Identifies pairs of adjacent cell IDs that form a boundary.
+
+        A boundary is defined where the difference in max water surface time
+        between two adjacent cells is greater than delta_t.
+        
+        Args:
+            cell_adjacency (Dict[int, List[int]]): Dictionary of cell adjacencies.
+            cell_times (Dict[int, pd.Timestamp]): Dictionary mapping cell IDs to their max WSE times.
+            delta_t (float): Time threshold in hours.
+
+        Returns:
+            List[Tuple[int, int]]: A list of tuples, where each tuple contains a pair of
+                                   cell IDs forming a boundary.
+        """
+        boundary_cell_pairs = []
+        processed_pairs = set()
+        delta_t_seconds = delta_t * 3600
+
+        for cell_id, neighbors in cell_adjacency.items():
+            time1 = cell_times.get(cell_id)
+            if not pd.notna(time1):
+                continue
+
+            for neighbor_id in neighbors:
+                pair = tuple(sorted((cell_id, neighbor_id)))
+                if pair in processed_pairs:
+                    continue
+
+                time2 = cell_times.get(neighbor_id)
+                if not pd.notna(time2):
+                    continue
+                
+                time_diff = abs((time1 - time2).total_seconds())
+
+                if time_diff >= delta_t_seconds:
+                    boundary_cell_pairs.append(pair)
+                
+                processed_pairs.add(pair)
+        
+        return boundary_cell_pairs
+
+    @staticmethod
+    def _identify_boundary_edges(
+        cell_adjacency: Dict[int, List[int]], 
+        common_edges: Dict[int, Dict[int, LineString]], 
+        cell_times: Dict[int, pd.Timestamp], 
+        delta_t: float,
+        min_line_length: Optional[float] = None
+    ) -> List[LineString]:
+        """
+        Identify boundary edges between cells with significant time differences.
+        
+        This function now uses the helper `_get_boundary_cell_pairs`.
+
+        Args:
+            cell_adjacency (Dict[int, List[int]]): Dictionary of cell adjacencies.
+            common_edges (Dict[int, Dict[int, LineString]]): Dictionary of shared edges between cells.
+            cell_times (Dict[int, pd.Timestamp]): Dictionary mapping cell IDs to their max WSE times.
+            delta_t (float): Time threshold in hours.
+            min_line_length (float, optional): Minimum length (in CRS units) for boundary lines to be included.
+                                               Lines shorter than this will be dropped. Default is None (no filtering).
+
+        Returns:
+            List[LineString]: List of LineString geometries representing boundaries.
+        """
+        boundary_pairs = HdfFluvialPluvial._get_boundary_cell_pairs(cell_adjacency, cell_times, delta_t)
+        
+        boundary_edges = [common_edges[c1][c2] for c1, c2 in boundary_pairs]
+        
+        logger.info(f"Identified {len(boundary_edges)} boundary edges using delta_t of {delta_t} hours.")
+
+        if min_line_length is not None:
+            filtered_edges = [edge for edge in boundary_edges if edge.length >= min_line_length]
+            num_dropped = len(boundary_edges) - len(filtered_edges)
+            if num_dropped > 0:
+                logger.info(f"{num_dropped} boundary line(s) shorter than {min_line_length} units were dropped after filtering.")
+            boundary_edges = filtered_edges
+
+        return boundary_edges

{ras_commander-0.77.0 → ras_commander-0.79.0}/ras_commander/HdfResultsMesh.py

@@ -42,22 +42,6 @@ HdfUtils for common operations. Methods use @log_call decorator for logging and
 
 
 
-REVISIONS MADE:
-
-Use get_ prefix for functions that return data.  
-BUT, we will never set results data, so we should use get_ for results data.
-
-Renamed functions:
-- mesh_summary_output() to get_mesh_summary()
-- mesh_timeseries_output() to get_mesh_timeseries()
-- mesh_faces_timeseries_output() to get_mesh_faces_timeseries()
-- mesh_cells_timeseries_output() to get_mesh_cells_timeseries()
-- mesh_last_iter() to get_mesh_last_iter()
-- mesh_max_ws() to get_mesh_max_ws()
-
-
-
-
 
 
 

{ras_commander-0.77.0 → ras_commander-0.79.0}/ras_commander/RasExamples.py

@@ -69,6 +69,12 @@ class RasExamples:
     examples_dir = base_dir
     projects_dir = examples_dir / 'example_projects'
     csv_file_path = examples_dir / 'example_projects.csv'
+    
+    # Special projects that are not in the main zip file
+    SPECIAL_PROJECTS = {
+        'NewOrleansMetro': 'https://www.hec.usace.army.mil/confluence/rasdocs/hgt/files/latest/299502039/299502111/1/1747692522764/NewOrleansMetroPipesExample.zip',
+        'BeaverLake': 'https://www.hec.usace.army.mil/confluence/rasdocs/hgt/files/latest/299501780/299502090/1/1747692179014/BeaverLake-SWMM-Import-Solution.zip'
+    }
 
     _folder_df = None
     _zip_file_path = None
@@ -148,6 +154,17 @@ class RasExamples:
         extracted_paths = []
 
         for project_name in project_names:
+            # Check if this is a special project
+            if project_name in cls.SPECIAL_PROJECTS:
+                try:
+                    special_path = cls._extract_special_project(project_name)
+                    extracted_paths.append(special_path)
+                    continue
+                except Exception as e:
+                    logger.error(f"Failed to extract special project '{project_name}': {e}")
+                    continue
+            
+            # Regular project extraction logic
             logger.info("----- RasExamples Extracting Project -----")
             logger.info(f"Extracting project '{project_name}'")
             project_path = cls.projects_dir
@@ -319,6 +336,9 @@ class RasExamples:
     def list_projects(cls, category=None):
         """
         List all projects or projects in a specific category.
+        
+        Note: Special projects (NewOrleansMetro, BeaverLake) are also available but not listed
+        in categories as they are downloaded separately.
         """
         if cls._folder_df is None:
             logger.warning("No projects available. Make sure the zip file is properly loaded.")
@@ -328,7 +348,10 @@ class RasExamples:
             logger.info(f"Projects in category '{category}': {', '.join(projects)}")
         else:
             projects = cls._folder_df['Project'].unique()
-            logger.info(f"All available projects: {', '.join(projects)}")
+            # Add special projects to the list
+            all_projects = list(projects) + list(cls.SPECIAL_PROJECTS.keys())
+            logger.info(f"All available projects: {', '.join(all_projects)}")
+            return all_projects
         return projects.tolist()
 
     @classmethod
@@ -421,4 +444,100 @@ class RasExamples:
             raise ValueError(f"Invalid size string: {size_str}")
         
         number, unit = float(re.findall(r'[\d\.]+', size_str)[0]), re.findall(r'[BKMGT]B?', size_str)[0]
-        return int(number * units[unit])
+        return int(number * units[unit])
+
+    @classmethod
+    def _extract_special_project(cls, project_name: str) -> Path:
+        """
+        Download and extract special projects that are not in the main zip file.
+        
+        Args:
+            project_name: Name of the special project ('NewOrleansMetro' or 'BeaverLake')
+            
+        Returns:
+            Path: Path to the extracted project directory
+            
+        Raises:
+            ValueError: If the project is not a recognized special project
+        """
+        if project_name not in cls.SPECIAL_PROJECTS:
+            raise ValueError(f"'{project_name}' is not a recognized special project")
+        
+        logger.info(f"----- RasExamples Extracting Special Project -----")
+        logger.info(f"Extracting special project '{project_name}'")
+        
+        # Create the project directory
+        project_path = cls.projects_dir / project_name
+        
+        # Check if already exists
+        if project_path.exists():
+            logger.info(f"Special project '{project_name}' already exists. Deleting existing folder...")
+            try:
+                shutil.rmtree(project_path)
+                logger.info(f"Existing folder for project '{project_name}' has been deleted.")
+            except Exception as e:
+                logger.error(f"Failed to delete existing project folder '{project_name}': {e}")
+                raise
+        
+        # Create the project directory
+        project_path.mkdir(parents=True, exist_ok=True)
+        
+        # Download the zip file
+        url = cls.SPECIAL_PROJECTS[project_name]
+        zip_file_path = cls.projects_dir / f"{project_name}_temp.zip"
+        
+        logger.info(f"Downloading special project from: {url}")
+        logger.info("This may take a few moments...")
+        
+        try:
+            response = requests.get(url, stream=True, timeout=300)
+            response.raise_for_status()
+            
+            # Get total file size if available
+            total_size = int(response.headers.get('content-length', 0))
+            
+            # Download with progress bar
+            with open(zip_file_path, 'wb') as file:
+                if total_size > 0:
+                    with tqdm(
+                        desc=f"Downloading {project_name}",
+                        total=total_size,
+                        unit='iB',
+                        unit_scale=True,
+                        unit_divisor=1024,
+                    ) as progress_bar:
+                        for chunk in response.iter_content(chunk_size=8192):
+                            size = file.write(chunk)
+                            progress_bar.update(size)
+                else:
+                    # No content length, download without progress bar
+                    for chunk in response.iter_content(chunk_size=8192):
+                        file.write(chunk)
+            
+            logger.info(f"Downloaded special project zip file to {zip_file_path}")
+            
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Failed to download special project '{project_name}': {e}")
+            if zip_file_path.exists():
+                zip_file_path.unlink()
+            raise
+        
+        # Extract the zip file directly to the project directory
+        try:
+            with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:
+                # Extract directly to the project directory (no internal folder structure)
+                zip_ref.extractall(project_path)
+            logger.info(f"Successfully extracted special project '{project_name}' to {project_path}")
+            
+        except Exception as e:
+            logger.error(f"Failed to extract special project '{project_name}': {e}")
+            if project_path.exists():
+                shutil.rmtree(project_path)
+            raise
+        finally:
+            # Clean up the temporary zip file
+            if zip_file_path.exists():
+                zip_file_path.unlink()
+                logger.debug(f"Removed temporary zip file: {zip_file_path}")
+        
+        return project_path

{ras_commander-0.77.0 → ras_commander-0.79.0}/ras_commander/RasGeo.py

@@ -206,10 +206,10 @@ class RasGeo:
         
         # Create DataFrame
         if base_table_rows:
-            df = pd.DataFrame(base_table_rows, columns=['Table Number', 'Land Cover Name', 'Base Manning\'s n Value'])
+            df = pd.DataFrame(base_table_rows, columns=['Table Number', 'Land Cover Name', 'Base Mannings n Value'])
             return df
         else:
-            return pd.DataFrame(columns=['Table Number', 'Land Cover Name', 'Base Manning\'s n Value'])
+            return pd.DataFrame(columns=['Table Number', 'Land Cover Name', 'Base Mannings n Value'])
 
 
     @staticmethod