ras-commander 0.42.0__py3-none-any.whl → 0.43.0__py3-none-any.whl

ras_commander/RasPrj.py

@@ -44,7 +44,8 @@ from pathlib import Path
 import pandas as pd
 from typing import Union, Any, List, Dict, Tuple
 import logging
-from ras_commander.logging_config import get_logger, log_call
+from ras_commander.LoggingConfig import get_logger
+from ras_commander.Decorators import log_call
 
 logger = get_logger(__name__)
 
@@ -87,6 +88,7 @@ class RasPrj:
         logger.info(f"Plan entries: {len(self.plan_df)}, Flow entries: {len(self.flow_df)}, "
                      f"Unsteady entries: {len(self.unsteady_df)}, Geometry entries: {len(self.geom_df)}, "
                      f"Boundary conditions: {len(self.boundaries_df)}")
+        logger.info(f"Geometry HDF files found: {self.plan_df['Geom_File'].notna().sum()}")
 
     @log_call
     def _load_project_data(self):
@@ -100,7 +102,36 @@ class RasPrj:
         self.plan_df = self._get_prj_entries('Plan')
         self.flow_df = self._get_prj_entries('Flow')
         self.unsteady_df = self._get_prj_entries('Unsteady')
-        self.geom_df = self._get_prj_entries('Geom')
+        self.geom_df = self.get_geom_entries()  # Use get_geom_entries instead of _get_prj_entries
+        
+        # Add Geom_File to plan_df
+        self.plan_df['Geom_File'] = self.plan_df.apply(lambda row: self._get_geom_file_for_plan(row['plan_number']), axis=1)
+
+    @log_call
+    def _get_geom_file_for_plan(self, plan_number):
+        """
+        Get the geometry file path for a given plan number.
+        
+        Args:
+            plan_number (str): The plan number to find the geometry file for.
+        
+        Returns:
+            str: The full path to the geometry HDF file, or None if not found.
+        """
+        plan_file_path = self.project_folder / f"{self.project_name}.p{plan_number}"
+        try:
+            with open(plan_file_path, 'r') as plan_file:
+                for line in plan_file:
+                    if line.startswith("Geom File="):
+                        geom_file = line.strip().split('=')[1]
+                        geom_hdf_path = self.project_folder / f"{self.project_name}.{geom_file}.hdf"
+                        if geom_hdf_path.exists():
+                            return str(geom_hdf_path)
+                        else:
+                            return None
+        except Exception as e:
+            logger.error(f"Error reading plan file for geometry: {e}")
+        return None
 
     @log_call
     def _parse_plan_file(self, plan_file_path):
@@ -381,16 +412,31 @@ class RasPrj:
     @log_call
     def get_geom_entries(self):
         """
-        Get all geometry entries from the HEC-RAS project.
+        Get geometry entries from the project file.
 
         Returns:
-            pd.DataFrame: A DataFrame containing all geometry entries.
-
-        Raises:
-            RuntimeError: If the project has not been initialized.
+            pd.DataFrame: DataFrame containing geometry entries.
         """
-        self.check_initialized()
-        return self._get_prj_entries('Geom')
+        geom_pattern = re.compile(r'Geom File=(\w+)')
+        geom_entries = []
+
+        try:
+            with open(self.prj_file, 'r') as f:
+                for line in f:
+                    match = geom_pattern.search(line)
+                    if match:
+                        geom_entries.append(match.group(1))
+        
+            geom_df = pd.DataFrame({'geom_file': geom_entries})
+            geom_df['geom_number'] = geom_df['geom_file'].str.extract(r'(\d+)$')
+            geom_df['full_path'] = geom_df['geom_file'].apply(lambda x: str(self.project_folder / f"{self.project_name}.{x}"))
+            geom_df['hdf_path'] = geom_df['full_path'] + ".hdf"
+            
+            logger.info(f"Found {len(geom_df)} geometry entries")
+            return geom_df
+        except Exception as e:
+            logger.error(f"Error reading geometry entries from project file: {e}")
+            raise
     
     @log_call
     def get_hdf_entries(self):

ras_commander/RasUnsteady.py

@@ -25,7 +25,8 @@ Example:
 import os
 from pathlib import Path
 from .RasPrj import ras
-from ras_commander.logging_config import get_logger, log_call
+from .LoggingConfig import get_logger
+from .Decorators import log_call
 
 logger = get_logger(__name__)
 

ras_commander/RasUtils.py

@@ -24,13 +24,19 @@ Example:
 import os
 from pathlib import Path
 from .RasPrj import ras
-from typing import Union, Optional, Dict, Callable
+from typing import Union, Optional, Dict, Callable, List, Tuple, Any
 import pandas as pd
 import numpy as np
 import shutil
-from ras_commander import get_logger
-from ras_commander.logging_config import get_logger, log_call
 import re
+from scipy.spatial import KDTree
+import datetime
+import time
+import h5py
+from datetime import timedelta
+from .LoggingConfig import get_logger
+from .Decorators import log_call
+
 
 logger = get_logger(__name__)
 # Module code starts here
@@ -41,76 +47,6 @@ class RasUtils:
     When integrating new functions that do not clearly fit into other classes, add them here.
     """
 
-    @staticmethod
-    @log_call
-    def create_backup(file_path: Path, backup_suffix: str = "_backup", ras_object=None) -> Path:
-        """
-        Create a backup of the specified file.
-
-        Parameters:
-        file_path (Path): Path to the file to be backed up
-        backup_suffix (str): Suffix to append to the backup file name
-        ras_object (RasPrj, optional): RAS object to use. If None, uses the default ras object.
-
-        Returns:
-        Path: Path to the created backup file
-
-        Example:
-        >>> backup_path = RasUtils.create_backup(Path("project.prj"))
-        >>> print(f"Backup created at: {backup_path}")
-        """
-        ras_obj = ras_object or ras
-        ras_obj.check_initialized()
-        
-        original_path = Path(file_path)
-        backup_path = original_path.with_name(f"{original_path.stem}{backup_suffix}{original_path.suffix}")
-        try:
-            shutil.copy2(original_path, backup_path)
-            logger.info(f"Backup created: {backup_path}")
-        except Exception as e:
-            logger.error(f"Failed to create backup for {original_path}: {e}")
-            raise
-        return backup_path
-
-    @staticmethod
-    @log_call
-    def restore_from_backup(backup_path: Path, remove_backup: bool = True, ras_object=None) -> Path:
-        """
-        Restore a file from its backup.
-
-        Parameters:
-        backup_path (Path): Path to the backup file
-        remove_backup (bool): Whether to remove the backup file after restoration
-        ras_object (RasPrj, optional): RAS object to use. If None, uses the default ras object.
-
-        Returns:
-        Path: Path to the restored file
-
-        Example:
-        >>> restored_path = RasUtils.restore_from_backup(Path("project_backup.prj"))
-        >>> print(f"File restored to: {restored_path}")
-        """
-        ras_obj = ras_object or ras
-        ras_obj.check_initialized()
-        
-        backup_path = Path(backup_path)
-        if '_backup' not in backup_path.stem:
-            logger.error(f"Backup suffix '_backup' not found in {backup_path.name}")
-            raise ValueError(f"Backup suffix '_backup' not found in {backup_path.name}")
-        
-        original_stem = backup_path.stem.rsplit('_backup', 1)[0]
-        original_path = backup_path.with_name(f"{original_stem}{backup_path.suffix}")
-        try:
-            shutil.copy2(backup_path, original_path)
-            logger.info(f"File restored: {original_path}")
-            if remove_backup:
-                backup_path.unlink()
-                logger.info(f"Backup removed: {backup_path}")
-        except Exception as e:
-            logger.error(f"Failed to restore from backup {backup_path}: {e}")
-            raise
-        return original_path
-
     @staticmethod
     @log_call
     def create_directory(directory_path: Path, ras_object=None) -> Path:
@@ -738,3 +674,192 @@ class RasUtils:
         except Exception as e:
             logger.exception(f"Failed to update project file {prj_file}")
             raise
+        
+  
+        
+        
+    # From FunkShuns
+        
+    @staticmethod
+    @log_call
+    def decode_byte_strings(dataframe: pd.DataFrame) -> pd.DataFrame:
+        """
+        Decodes byte strings in a DataFrame to regular string objects.
+
+        This function converts columns with byte-encoded strings (e.g., b'string') into UTF-8 decoded strings.
+
+        Args:
+            dataframe (pd.DataFrame): The DataFrame containing byte-encoded string columns.
+
+        Returns:
+            pd.DataFrame: The DataFrame with byte strings decoded to regular strings.
+
+        Example:
+            >>> df = pd.DataFrame({'A': [b'hello', b'world'], 'B': [1, 2]})
+            >>> decoded_df = RasUtils.decode_byte_strings(df)
+            >>> print(decoded_df)
+                A  B
+            0  hello  1
+            1  world  2
+        """
+        str_df = dataframe.select_dtypes(['object'])
+        str_df = str_df.stack().str.decode('utf-8').unstack()
+        for col in str_df:
+            dataframe[col] = str_df[col]
+        return dataframe
+
+    @staticmethod
+    @log_call
+    def perform_kdtree_query(
+        reference_points: np.ndarray,
+        query_points: np.ndarray,
+        max_distance: float = 2.0
+    ) -> np.ndarray:
+        """
+        Performs a KDTree query between two datasets and returns indices with distances exceeding max_distance set to -1.
+
+        Args:
+            reference_points (np.ndarray): The reference dataset for KDTree.
+            query_points (np.ndarray): The query dataset to search against KDTree of reference_points.
+            max_distance (float, optional): The maximum distance threshold. Indices with distances greater than this are set to -1. Defaults to 2.0.
+
+        Returns:
+            np.ndarray: Array of indices from reference_points that are nearest to each point in query_points. 
+                        Indices with distances > max_distance are set to -1.
+
+        Example:
+            >>> ref_points = np.array([[0, 0], [1, 1], [2, 2]])
+            >>> query_points = np.array([[0.5, 0.5], [3, 3]])
+            >>> result = RasUtils.perform_kdtree_query(ref_points, query_points)
+            >>> print(result)
+            array([ 0, -1])
+        """
+        dist, snap = KDTree(reference_points).query(query_points, distance_upper_bound=max_distance)
+        snap[dist > max_distance] = -1
+        return snap
+
+    @staticmethod
+    @log_call
+    def find_nearest_neighbors(points: np.ndarray, max_distance: float = 2.0) -> np.ndarray:
+        """
+        Creates a self KDTree for dataset points and finds nearest neighbors excluding self, 
+        with distances above max_distance set to -1.
+
+        Args:
+            points (np.ndarray): The dataset to build the KDTree from and query against itself.
+            max_distance (float, optional): The maximum distance threshold. Indices with distances 
+                                            greater than max_distance are set to -1. Defaults to 2.0.
+
+        Returns:
+            np.ndarray: Array of indices representing the nearest neighbor in points for each point in points. 
+                        Indices with distances > max_distance or self-matches are set to -1.
+
+        Example:
+            >>> points = np.array([[0, 0], [1, 1], [2, 2], [10, 10]])
+            >>> result = RasUtils.find_nearest_neighbors(points)
+            >>> print(result)
+            array([1, 0, 1, -1])
+        """
+        dist, snap = KDTree(points).query(points, k=2, distance_upper_bound=max_distance)
+        snap[dist > max_distance] = -1
+        
+        snp = pd.DataFrame(snap, index=np.arange(len(snap)))
+        snp = snp.replace(-1, np.nan)
+        snp.loc[snp[0] == snp.index, 0] = np.nan
+        snp.loc[snp[1] == snp.index, 1] = np.nan
+        filled = snp[0].fillna(snp[1])
+        snapped = filled.fillna(-1).astype(np.int64).to_numpy()
+        return snapped
+
+    @staticmethod
+    @log_call
+    def consolidate_dataframe(
+        dataframe: pd.DataFrame,
+        group_by: Optional[Union[str, List[str]]] = None,
+        pivot_columns: Optional[Union[str, List[str]]] = None,
+        level: Optional[int] = None,
+        n_dimensional: bool = False,
+        aggregation_method: Union[str, Callable] = 'list'
+    ) -> pd.DataFrame:
+        """
+        Consolidate rows in a DataFrame by merging duplicate values into lists or using a specified aggregation function.
+
+        Args:
+            dataframe (pd.DataFrame): The DataFrame to consolidate.
+            group_by (Optional[Union[str, List[str]]]): Columns or indices to group by.
+            pivot_columns (Optional[Union[str, List[str]]]): Columns to pivot.
+            level (Optional[int]): Level of multi-index to group by.
+            n_dimensional (bool): If True, use a pivot table for N-Dimensional consolidation.
+            aggregation_method (Union[str, Callable]): Aggregation method, e.g., 'list' to aggregate into lists.
+
+        Returns:
+            pd.DataFrame: The consolidated DataFrame.
+
+        Example:
+            >>> df = pd.DataFrame({'A': [1, 1, 2], 'B': [4, 5, 6], 'C': [7, 8, 9]})
+            >>> result = RasUtils.consolidate_dataframe(df, group_by='A')
+            >>> print(result)
+            B         C
+            A            
+            1  [4, 5]  [7, 8]
+            2  [6]     [9]
+        """
+        if aggregation_method == 'list':
+            agg_func = lambda x: tuple(x)
+        else:
+            agg_func = aggregation_method
+
+        if n_dimensional:
+            result = dataframe.pivot_table(group_by, pivot_columns, aggfunc=agg_func)
+        else:
+            result = dataframe.groupby(group_by, level=level).agg(agg_func).applymap(list)
+
+        return result
+
+    @staticmethod
+    @log_call
+    def find_nearest_value(array: Union[list, np.ndarray], target_value: Union[int, float]) -> Union[int, float]:
+        """
+        Finds the nearest value in a NumPy array to the specified target value.
+
+        Args:
+            array (Union[list, np.ndarray]): The array to search within.
+            target_value (Union[int, float]): The value to find the nearest neighbor to.
+
+        Returns:
+            Union[int, float]: The nearest value in the array to the specified target value.
+
+        Example:
+            >>> arr = np.array([1, 3, 5, 7, 9])
+            >>> result = RasUtils.find_nearest_value(arr, 6)
+            >>> print(result)
+            5
+        """
+        array = np.asarray(array)
+        idx = (np.abs(array - target_value)).argmin()
+        return array[idx]
+    
+    @classmethod
+    @log_call
+    def horizontal_distance(cls, coord1: np.ndarray, coord2: np.ndarray) -> float:
+        """
+        Calculate the horizontal distance between two coordinate points.
+        
+        Args:
+            coord1 (np.ndarray): First coordinate point [X, Y].
+            coord2 (np.ndarray): Second coordinate point [X, Y].
+        
+        Returns:
+            float: Horizontal distance.
+        
+        Example:
+            >>> distance = RasUtils.horizontal_distance(np.array([0, 0]), np.array([3, 4]))
+            >>> print(distance)
+            5.0
+        """
+        return np.linalg.norm(coord2 - coord1)
+    
+    
+    
+    
+    

ras_commander/__init__.py

@@ -1,5 +1,6 @@
 from importlib.metadata import version, PackageNotFoundError
-from .logging_config import setup_logging, get_logger, log_call
+from .LoggingConfig import setup_logging, get_logger
+from .Decorators import log_call, standardize_input
 
 try:
     __version__ = version("ras-commander")
@@ -11,19 +12,40 @@ except PackageNotFoundError:
 setup_logging()
 
 # Import all necessary functions and classes directly
-from .RasPrj import ras, init_ras_project, get_ras_exe
-from .RasPrj import RasPrj
+from .RasPrj import RasPrj, init_ras_project, get_ras_exe, ras
 from .RasPlan import RasPlan
 from .RasGeo import RasGeo
 from .RasUnsteady import RasUnsteady
-from .RasCmdr import RasCmdr
 from .RasUtils import RasUtils
 from .RasExamples import RasExamples
-from .RasHdf import RasHdf
+from .RasCmdr import RasCmdr
 from .RasGpt import RasGpt
 
+# Import the Hdf* classes
+from .HdfBase import HdfBase
+from .HdfBndry import HdfBndry
+from .HdfMesh import HdfMesh
+from .HdfPlan import HdfPlan
+from .HdfResultsMesh import HdfResultsMesh
+from .HdfResultsPlan import HdfResultsPlan
+from .HdfResultsXsec import HdfResultsXsec
+from .HdfStruc import HdfStruc
+from .HdfUtils import HdfUtils
+from .HdfXsec import HdfXsec
+
 # Define __all__ to specify what should be imported when using "from ras_commander import *"
 __all__ = [
+    "HdfBase",
+    "HdfBndry",
+    "HdfMesh",
+    "HdfPlan",
+    "HdfResultsMesh",
+    "HdfResultsPlan",
+    "HdfResultsXsec",
+    "HdfStruc",
+    "HdfUtils",
+    "HdfXsec",
+    "standardize_input",
     "ras",
     "init_ras_project",
     "get_ras_exe",
@@ -34,8 +56,8 @@ __all__ = [
     "RasCmdr",
     "RasUtils",
     "RasExamples",
-    "RasHdf",
-    "RasGpt",
     "get_logger",
-    "log_call"
-]
+    "log_call",
+]
+
+__version__ = "0.1.0"

{ras_commander-0.42.0.dist-info → ras_commander-0.43.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ras-commander
-Version: 0.42.0
+Version: 0.43.0
 Summary: A Python library for automating HEC-RAS operations
 Home-page: https://github.com/billk-FM/ras-commander
 Author: William M. Katzenmeyer

ras_commander-0.43.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+ras_commander/Decorators.py,sha256=i5AEQbe7JeI8Y3O_dQ5OO4Ab0KO5SiZTiysFBGxqTRU,4978
+ras_commander/HdfBase.py,sha256=xAaQdHa80EAjhjjp2UMLIFzWf7xVncunj0bxbPJciFg,6863
+ras_commander/HdfBndry.py,sha256=dXyM9yVEyNcvCJFsCr5R6XY1V8LnDUQTbScnkeqSuuI,20469
+ras_commander/HdfMesh.py,sha256=EETuwOqDnmus1tbATmfANq5MLoN6GTw6K9IAm5vGqx0,12386
+ras_commander/HdfPlan.py,sha256=gj34nSlzXOxa5EPYNYoL9ocWa83lzUuMOMl7kvKzaIk,6674
+ras_commander/HdfResultsMesh.py,sha256=vFR3DpyS55W_QhgCypYKq6bRFwjIBc8D4ql9ZISn9RY,28295
+ras_commander/HdfResultsPlan.py,sha256=htRCxZh26_fwgZtJt5USifcapUg0WRChsZRWzgC4bMU,17141
+ras_commander/HdfResultsXsec.py,sha256=nxj0WUA149EoB_WjlIqlGyb3QJt4LMc32X7unsJM62A,8126
+ras_commander/HdfStruc.py,sha256=P9rEfmvqlD1CgJ7OFzBm4ST3K-5IrxmrON6PwT68yMg,5303
+ras_commander/HdfUtils.py,sha256=94ojuG7FV_IT9KjYIBS_zL8LqdmVi1s0eppXnY-_338,18274
+ras_commander/HdfXsec.py,sha256=moPbWcGhoIK5xEKoFvebTOKNlcwXAmQtQVZW9DTlhzQ,11269
+ras_commander/LoggingConfig.py,sha256=5bYd_5KMlf81bXsiu2mABBlw0USMhcu5uRv8DIYJSFE,2317
+ras_commander/RasCmdr.py,sha256=qZtdvwQnZxOjhU3pZWRCJ80aH5QWOJD_F7P_05geSHA,25020
+ras_commander/RasExamples.py,sha256=FDit6FWzTQbv42Xx0gtSJB17HDeol_eykxV0qVpnwIk,16688
+ras_commander/RasGeo.py,sha256=x7eFvUQ_dPZxAVq2Gw_GIRzn-Cf7DLKZDTwk1fjrkf8,5395
+ras_commander/RasGpt.py,sha256=1Nitlf5QyeBQo8Q8I8pJKaTtQ0GdsBQA71LIKUAOycA,839
+ras_commander/RasPlan.py,sha256=_0EjxQnamd9FhzzKlYNqJ3chv2bvxfk0DXEwfHntXFo,40287
+ras_commander/RasPrj.py,sha256=ePLcPNcKVMgijvJKkJIWwQslQi2D6zq2UTW-8XCFmto,36159
+ras_commander/RasUnsteady.py,sha256=oBVC9QFQMrSx8LY2Cb1CjUyCQEUoIEnEuVJsATYiVYs,4649
+ras_commander/RasUtils.py,sha256=NBMxTHWHoTH2MJzqJ0y1_00fgKSS1GnNuEikwZ3Pqzs,34153
+ras_commander/__init__.py,sha256=3MuobRXVEQNvoGwf9AlbvuJg8meni3eWw_JZMFOuMt4,1630
+ras_commander-0.43.0.dist-info/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
+ras_commander-0.43.0.dist-info/METADATA,sha256=yMVLfZpTzUgJVVR-njq5izBxTcgwBHVVr6238PHvG2M,15671
+ras_commander-0.43.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+ras_commander-0.43.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
+ras_commander-0.43.0.dist-info/RECORD,,