ras-commander 0.35.0__py3-none-any.whl → 0.36.0__py3-none-any.whl

ras_commander/RasUnsteady.py

@@ -1,21 +1,35 @@
 """
-Operations for handling unsteady flow files in HEC-RAS projects.
+RasUnsteady - Operations for handling unsteady flow files in HEC-RAS projects.
+
+This module is part of the ras-commander library and uses a centralized logging configuration.
+
+Logging Configuration:
+- The logging is set up in the logging_config.py file.
+- A @log_call decorator is available to automatically log function calls.
+- Log levels: DEBUG, INFO, WARNING, ERROR, CRITICAL
+- Logs are written to both console and a rotating file handler.
+- The default log file is 'ras_commander.log' in the 'logs' directory.
+- The default log level is INFO.
+
+To use logging in this module:
+1. Use the @log_call decorator for automatic function call logging.
+2. For additional logging, use logger.[level]() calls (e.g., logger.info(), logger.debug()).
+
+
+Example:
+    @log_call
+    def my_function():
+        logger.debug("Additional debug information")
+        # Function logic here
 """
+import os
 from pathlib import Path
 from .RasPrj import ras
-import logging
-import re
+from ras_commander.logging_config import get_logger, log_call
+
+logger = get_logger(__name__)
 
-# Configure logging at the module level
-logging.basicConfig(
-    level=logging.INFO,  # Set to DEBUG for more detailed output
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler(),  # Logs to console
-        # Uncomment the next line to enable logging to a file
-        # logging.FileHandler('ras_unsteady.log')
-    ]
-)
+# Module code starts here
 
 class RasUnsteady:
     """
@@ -23,6 +37,7 @@ class RasUnsteady:
     """
     
     @staticmethod
+    @log_call
     def update_unsteady_parameters(unsteady_file, modifications, ras_object=None):
         """
         Modify parameters in an unsteady flow file.
@@ -58,12 +73,12 @@ class RasUnsteady:
         try:
             with open(unsteady_path, 'r') as f:
                 lines = f.readlines()
-            logging.debug(f"Successfully read unsteady flow file: {unsteady_path}")
+            logger.debug(f"Successfully read unsteady flow file: {unsteady_path}")
         except FileNotFoundError:
-            logging.error(f"Unsteady flow file not found: {unsteady_path}")
+            logger.error(f"Unsteady flow file not found: {unsteady_path}")
             raise FileNotFoundError(f"Unsteady flow file not found: {unsteady_path}")
         except PermissionError:
-            logging.error(f"Permission denied when reading unsteady flow file: {unsteady_path}")
+            logger.error(f"Permission denied when reading unsteady flow file: {unsteady_path}")
             raise PermissionError(f"Permission denied when reading unsteady flow file: {unsteady_path}")
         
         updated = False
@@ -73,21 +88,21 @@ class RasUnsteady:
                     old_value = line.strip().split('=')[1]
                     lines[i] = f"{param}={new_value}\n"
                     updated = True
-                    logging.info(f"Updated {param} from {old_value} to {new_value}")
+                    logger.info(f"Updated {param} from {old_value} to {new_value}")
         
         if updated:
             try:
                 with open(unsteady_path, 'w') as f:
                     f.writelines(lines)
-                logging.debug(f"Successfully wrote modifications to unsteady flow file: {unsteady_path}")
+                logger.debug(f"Successfully wrote modifications to unsteady flow file: {unsteady_path}")
             except PermissionError:
-                logging.error(f"Permission denied when writing to unsteady flow file: {unsteady_path}")
+                logger.error(f"Permission denied when writing to unsteady flow file: {unsteady_path}")
                 raise PermissionError(f"Permission denied when writing to unsteady flow file: {unsteady_path}")
             except IOError as e:
-                logging.error(f"Error writing to unsteady flow file: {unsteady_path}. {str(e)}")
+                logger.error(f"Error writing to unsteady flow file: {unsteady_path}. {str(e)}")
                 raise IOError(f"Error writing to unsteady flow file: {unsteady_path}. {str(e)}")
-            logging.info(f"Applied modifications to {unsteady_file}")
+            logger.info(f"Applied modifications to {unsteady_file}")
         else:
-            logging.warning(f"No matching parameters found in {unsteady_file}")
+            logger.warning(f"No matching parameters found in {unsteady_file}")
     
         ras_obj.unsteady_df = ras_obj.get_unsteady_entries()

ras_commander/RasUtils.py

@@ -1,21 +1,38 @@
 """
-Utility functions for the ras-commander library.
+RasUtils - Utility functions for the ras-commander library
+
+This module is part of the ras-commander library and uses a centralized logging configuration.
+
+Logging Configuration:
+- The logging is set up in the logging_config.py file.
+- A @log_call decorator is available to automatically log function calls.
+- Log levels: DEBUG, INFO, WARNING, ERROR, CRITICAL
+- Logs are written to both console and a rotating file handler.
+- The default log file is 'ras_commander.log' in the 'logs' directory.
+- The default log level is INFO.
+
+To use logging in this module:
+1. Use the @log_call decorator for automatic function call logging.
+2. For additional logging, use logger.[level]() calls (e.g., logger.info(), logger.debug()).
+
+Example:
+    @log_call
+    def my_function():
+        logger.debug("Additional debug information")
+        # Function logic here
 """
 import os
-import shutil
-import logging
-import time
 from pathlib import Path
 from .RasPrj import ras
 from typing import Union, Optional, Dict
 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
 
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s'
-)
+logger = get_logger(__name__)
+# Module code starts here
 
 class RasUtils:
     """
@@ -24,6 +41,7 @@ class RasUtils:
     """
 
     @staticmethod
+    @log_call
     def create_backup(file_path: Path, backup_suffix: str = "_backup", ras_object=None) -> Path:
         """
         Create a backup of the specified file.
@@ -47,13 +65,14 @@ class RasUtils:
         backup_path = original_path.with_name(f"{original_path.stem}{backup_suffix}{original_path.suffix}")
         try:
             shutil.copy2(original_path, backup_path)
-            logging.info(f"Backup created: {backup_path}")
+            logger.info(f"Backup created: {backup_path}")
         except Exception as e:
-            logging.error(f"Failed to create backup for {original_path}: {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.
@@ -75,23 +94,24 @@ class RasUtils:
         
         backup_path = Path(backup_path)
         if '_backup' not in backup_path.stem:
-            logging.error(f"Backup suffix '_backup' not found in {backup_path.name}")
+            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)
-            logging.info(f"File restored: {original_path}")
+            logger.info(f"File restored: {original_path}")
             if remove_backup:
                 backup_path.unlink()
-                logging.info(f"Backup removed: {backup_path}")
+                logger.info(f"Backup removed: {backup_path}")
         except Exception as e:
-            logging.error(f"Failed to restore from backup {backup_path}: {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:
         """
         Ensure that a directory exists, creating it if necessary.
@@ -113,13 +133,14 @@ class RasUtils:
         path = Path(directory_path)
         try:
             path.mkdir(parents=True, exist_ok=True)
-            logging.info(f"Directory ensured: {path}")
+            logger.info(f"Directory ensured: {path}")
         except Exception as e:
-            logging.error(f"Failed to create directory {path}: {e}")
+            logger.error(f"Failed to create directory {path}: {e}")
             raise
         return path
 
     @staticmethod
+    @log_call
     def find_files_by_extension(extension: str, ras_object=None) -> list:
         """
         List all files in the project directory with a specific extension.
@@ -141,13 +162,14 @@ class RasUtils:
         try:
             files = list(ras_obj.project_folder.glob(f"*{extension}"))
             file_list = [str(file) for file in files]
-            logging.info(f"Found {len(file_list)} files with extension '{extension}' in {ras_obj.project_folder}")
+            logger.info(f"Found {len(file_list)} files with extension '{extension}' in {ras_obj.project_folder}")
             return file_list
         except Exception as e:
-            logging.error(f"Failed to find files with extension '{extension}': {e}")
+            logger.error(f"Failed to find files with extension '{extension}': {e}")
             raise
 
     @staticmethod
+    @log_call
     def get_file_size(file_path: Path, ras_object=None) -> Optional[int]:
         """
         Get the size of a file in bytes.
@@ -170,16 +192,17 @@ class RasUtils:
         if path.exists():
             try:
                 size = path.stat().st_size
-                logging.info(f"Size of {path}: {size} bytes")
+                logger.info(f"Size of {path}: {size} bytes")
                 return size
             except Exception as e:
-                logging.error(f"Failed to get size for {path}: {e}")
+                logger.error(f"Failed to get size for {path}: {e}")
                 raise
         else:
-            logging.warning(f"File not found: {path}")
+            logger.warning(f"File not found: {path}")
             return None
 
     @staticmethod
+    @log_call
     def get_file_modification_time(file_path: Path, ras_object=None) -> Optional[float]:
         """
         Get the last modification time of a file.
@@ -195,6 +218,7 @@ class RasUtils:
         >>> mtime = RasUtils.get_file_modification_time(Path("project.prj"))
         >>> print(f"Last modified: {mtime}")
         """
+        
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
         
@@ -202,16 +226,17 @@ class RasUtils:
         if path.exists():
             try:
                 mtime = path.stat().st_mtime
-                logging.info(f"Last modification time of {path}: {mtime}")
+                logger.info(f"Last modification time of {path}: {mtime}")
                 return mtime
             except Exception as e:
-                logging.error(f"Failed to get modification time for {path}: {e}")
+                logger.exception(f"Failed to get modification time for {path}")
                 raise
         else:
-            logging.warning(f"File not found: {path}")
+            logger.warning(f"File not found: {path}")
             return None
 
     @staticmethod
+    @log_call
     def get_plan_path(current_plan_number_or_path: Union[str, Path], ras_object=None) -> Path:
         """
         Get the path for a plan file with a given plan number or path.
@@ -229,27 +254,29 @@ class RasUtils:
         >>> plan_path = RasUtils.get_plan_path("path/to/plan.p01")
         >>> print(f"Plan file path: {plan_path}")
         """
+        
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
         
         plan_path = Path(current_plan_number_or_path)
         if plan_path.is_file():
-            logging.info(f"Using provided plan file path: {plan_path}")
+            logger.info(f"Using provided plan file path: {plan_path}")
             return plan_path
         
         try:
             current_plan_number = f"{int(current_plan_number_or_path):02d}"  # Ensure two-digit format
-            logging.info(f"Converted plan number to two-digit format: {current_plan_number}")
+            logger.debug(f"Converted plan number to two-digit format: {current_plan_number}")
         except ValueError:
-            logging.error(f"Invalid plan number: {current_plan_number_or_path}. Expected a number from 1 to 99.")
+            logger.error(f"Invalid plan number: {current_plan_number_or_path}. Expected a number from 1 to 99.")
             raise ValueError(f"Invalid plan number: {current_plan_number_or_path}. Expected a number from 1 to 99.")
         
         plan_name = f"{ras_obj.project_name}.p{current_plan_number}"
         full_plan_path = ras_obj.project_folder / plan_name
-        logging.info(f"Constructed plan file path: {full_plan_path}")
+        logger.info(f"Constructed plan file path: {full_plan_path}")
         return full_plan_path
 
     @staticmethod
+    @log_call
     def remove_with_retry(
         path: Path,
         max_attempts: int = 5,
@@ -274,6 +301,7 @@ class RasUtils:
         >>> success = RasUtils.remove_with_retry(Path("temp_folder"), is_folder=True)
         >>> print(f"Removal successful: {success}")
         """
+        
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
 
@@ -283,32 +311,33 @@ class RasUtils:
                 if path.exists():
                     if is_folder:
                         shutil.rmtree(path)
-                        logging.info(f"Folder removed: {path}")
+                        logger.info(f"Folder removed: {path}")
                     else:
                         path.unlink()
-                        logging.info(f"File removed: {path}")
+                        logger.info(f"File removed: {path}")
                 else:
-                    logging.info(f"Path does not exist, nothing to remove: {path}")
+                    logger.info(f"Path does not exist, nothing to remove: {path}")
                 return True
             except PermissionError as pe:
                 if attempt < max_attempts:
                     delay = initial_delay * (2 ** (attempt - 1))  # Exponential backoff
-                    logging.warning(
+                    logger.warning(
                         f"PermissionError on attempt {attempt} to remove {path}: {pe}. "
                         f"Retrying in {delay} seconds..."
                     )
                     time.sleep(delay)
                 else:
-                    logging.error(
+                    logger.error(
                         f"Failed to remove {path} after {max_attempts} attempts due to PermissionError: {pe}. Skipping."
                     )
                     return False
             except Exception as e:
-                logging.error(f"Failed to remove {path} on attempt {attempt}: {e}")
+                logger.exception(f"Failed to remove {path} on attempt {attempt}")
                 return False
         return False
 
     @staticmethod
+    @log_call
     def update_plan_file(
         plan_number_or_path: Union[str, Path],
         file_type: str,
@@ -332,12 +361,13 @@ class RasUtils:
         >>> RasUtils.update_plan_file(1, "Geom", 2)
         >>> RasUtils.update_plan_file("path/to/plan.p01", "Geom", 2)
         """
+        
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
         
         valid_file_types = {'Geom': 'g', 'Flow': 'f', 'Unsteady': 'u'}
         if file_type not in valid_file_types:
-            logging.error(
+            logger.error(
                 f"Invalid file_type '{file_type}'. Expected one of: {', '.join(valid_file_types.keys())}"
             )
             raise ValueError(
@@ -348,7 +378,7 @@ class RasUtils:
         if not plan_file_path.is_file():
             plan_file_path = RasUtils.get_plan_path(plan_number_or_path, ras_object)
             if not plan_file_path.exists():
-                logging.error(f"Plan file not found: {plan_file_path}")
+                logger.error(f"Plan file not found: {plan_file_path}")
                 raise FileNotFoundError(f"Plan file not found: {plan_file_path}")
         
         file_prefix = valid_file_types[file_type]
@@ -360,30 +390,30 @@ class RasUtils:
             with plan_file_path.open('r') as file:
                 lines = file.readlines()
         except Exception as e:
-            logging.error(f"Failed to read plan file {plan_file_path}: {e}")
+            logger.exception(f"Failed to read plan file {plan_file_path}")
             raise
 
         updated = False
         for i, line in enumerate(lines):
             if line.startswith(search_pattern):
                 lines[i] = f"{search_pattern}{file_prefix}{formatted_entry_number}\n"
-                logging.info(
+                logger.info(
                     f"Updated {file_type} File in {plan_file_path} to {file_prefix}{formatted_entry_number}"
                 )
                 updated = True
                 break
 
         if not updated:
-            logging.warning(
+            logger.warning(
                 f"Search pattern '{search_pattern}' not found in {plan_file_path}. No update performed."
             )
 
         try:
             with plan_file_path.open('w') as file:
                 file.writelines(lines)
-            logging.info(f"Successfully updated plan file: {plan_file_path}")
+            logger.info(f"Successfully updated plan file: {plan_file_path}")
         except Exception as e:
-            logging.error(f"Failed to write updates to plan file {plan_file_path}: {e}")
+            logger.exception(f"Failed to write updates to plan file {plan_file_path}")
             raise
 
         # Refresh RasPrj dataframes
@@ -392,12 +422,13 @@ class RasUtils:
             ras_obj.geom_df = ras_obj.get_geom_entries()
             ras_obj.flow_df = ras_obj.get_flow_entries()
             ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
-            logging.info("RAS object dataframes have been refreshed.")
+            logger.info("RAS object dataframes have been refreshed.")
         except Exception as e:
-            logging.error(f"Failed to refresh RasPrj dataframes: {e}")
+            logger.exception("Failed to refresh RasPrj dataframes")
             raise
 
     @staticmethod
+    @log_call
     def check_file_access(file_path: Path, mode: str = 'r') -> None:
         """
         Check if the file can be accessed with the specified mode.
@@ -410,36 +441,30 @@ class RasUtils:
         FileNotFoundError: If the file does not exist
         PermissionError: If the required permissions are not met
         """
+        
         path = Path(file_path)
         if not path.exists():
-            logging.error(f"File not found: {file_path}")
+            logger.error(f"File not found: {file_path}")
             raise FileNotFoundError(f"File not found: {file_path}")
         
         if mode in ('r', 'rb'):
             if not os.access(path, os.R_OK):
-                logging.error(f"Read permission denied for file: {file_path}")
+                logger.error(f"Read permission denied for file: {file_path}")
                 raise PermissionError(f"Read permission denied for file: {file_path}")
             else:
-                logging.debug(f"Read access granted for file: {file_path}")
+                logger.debug(f"Read access granted for file: {file_path}")
         
         if mode in ('w', 'wb', 'a', 'ab'):
             parent_dir = path.parent
             if not os.access(parent_dir, os.W_OK):
-                logging.error(f"Write permission denied for directory: {parent_dir}")
+                logger.error(f"Write permission denied for directory: {parent_dir}")
                 raise PermissionError(f"Write permission denied for directory: {parent_dir}")
             else:
-                logging.debug(f"Write access granted for directory: {parent_dir}")
-
-
-
-
-#  --------------------------   Functions below were imported from funkshuns.py  --------------------------
-#  --------------------------   Converted to ras-commander style guide   ----------------------------------
-
-
+                logger.debug(f"Write access granted for directory: {parent_dir}")
 
 
     @staticmethod
+    @log_call
     def convert_to_dataframe(data_source: Union[pd.DataFrame, Path], **kwargs) -> pd.DataFrame:
         """
         Converts input to a pandas DataFrame. Supports existing DataFrames or file paths (CSV, Excel, TSV, Parquet).
@@ -458,13 +483,13 @@ class RasUtils:
             >>> df = RasUtils.convert_to_dataframe(Path("data.csv"))
             >>> print(type(df))
             <class 'pandas.core.frame.DataFrame'>
-            
-        Attribution Note: This function is sourced from funkshuns.py by Sean Micek, and converted to the ras-commander style guide.
         """
         if isinstance(data_source, pd.DataFrame):
+            logger.debug("Input is already a DataFrame, returning a copy.")
             return data_source.copy()
         elif isinstance(data_source, Path):
             ext = data_source.suffix.replace('.', '', 1)
+            logger.info(f"Converting file with extension '{ext}' to DataFrame.")
             if ext == 'csv':
                 return pd.read_csv(data_source, **kwargs)
             elif ext.startswith('x'):
@@ -474,11 +499,14 @@ class RasUtils:
             elif ext in ["parquet", "pq", "parq"]:
                 return pd.read_parquet(data_source, **kwargs)
             else:
+                logger.error(f"Unsupported file type: {ext}")
                 raise NotImplementedError(f"Unsupported file type {ext}. Should be one of csv, tsv, parquet, or xlsx.")
         else:
+            logger.error(f"Unsupported input type: {type(data_source)}")
             raise NotImplementedError(f"Unsupported type {type(data_source)}. Only file path / existing DataFrame supported at this time")
 
     @staticmethod
+    @log_call
     def save_to_excel(dataframe: pd.DataFrame, excel_path: Path, **kwargs) -> None:
         """
         Saves a pandas DataFrame to an Excel file with retry functionality.
@@ -494,8 +522,6 @@ class RasUtils:
         Example:
             >>> df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
             >>> RasUtils.save_to_excel(df, Path('output.xlsx'))
-            
-        Attribution Note: This function is sourced from funkshuns.py by Sean Micek, and converted to the ras-commander style guide.
         """
         saved = False
         max_attempts = 3
@@ -504,28 +530,18 @@ class RasUtils:
         while not saved and attempt < max_attempts:
             try:
                 dataframe.to_excel(excel_path, **kwargs)
-                print(f'DataFrame successfully saved to \n{excel_path}')
+                logger.info(f'DataFrame successfully saved to {excel_path}')
                 saved = True
             except IOError as e:
                 attempt += 1
                 if attempt < max_attempts:
-                    print(f"Error saving file. Attempt {attempt} of {max_attempts}. Please close the Excel document if it's open.")
+                    logger.warning(f"Error saving file. Attempt {attempt} of {max_attempts}. Please close the Excel document if it's open.")
                 else:
+                    logger.error(f"Failed to save {excel_path} after {max_attempts} attempts.")
                     raise IOError(f"Failed to save {excel_path} after {max_attempts} attempts. Last error: {str(e)}")
 
-
-
-
-
-
-
-
-
-
-#####  Statistical Metrics #####
-
-
     @staticmethod
+    @log_call
     def calculate_rmse(observed_values: np.ndarray, predicted_values: np.ndarray, normalized: bool = True) -> float:
         """
         Calculate the Root Mean Squared Error (RMSE) between observed and predicted values.
@@ -543,17 +559,17 @@ class RasUtils:
             >>> predicted = np.array([1.1, 2.2, 2.9])
             >>> RasUtils.calculate_rmse(observed, predicted)
             0.06396394
-            
-        Attribution Note: This function is sourced from funkshuns.py by Sean Micek, and converted to the ras-commander style guide.
         """
         rmse = np.sqrt(np.mean((predicted_values - observed_values) ** 2))
         
         if normalized:
             rmse = rmse / np.abs(np.mean(observed_values))
         
+        logger.debug(f"Calculated RMSE: {rmse}")
         return rmse
 
     @staticmethod
+    @log_call
     def calculate_percent_bias(observed_values: np.ndarray, predicted_values: np.ndarray, as_percentage: bool = False) -> float:
         """
         Calculate the Percent Bias between observed and predicted values.
@@ -571,16 +587,16 @@ class RasUtils:
             >>> predicted = np.array([1.1, 2.2, 2.9])
             >>> RasUtils.calculate_percent_bias(observed, predicted, as_percentage=True)
             3.33333333
-            
-        Attribution Note: This function is sourced from funkshuns.py by Sean Micek, and converted to the ras-commander style guide.
         """
         multiplier = 100 if as_percentage else 1
         
         percent_bias = multiplier * (np.mean(predicted_values) - np.mean(observed_values)) / np.mean(observed_values)
         
+        logger.debug(f"Calculated Percent Bias: {percent_bias}")
         return percent_bias
 
     @staticmethod
+    @log_call
     def calculate_error_metrics(observed_values: np.ndarray, predicted_values: np.ndarray) -> Dict[str, float]:
         """
         Compute a trio of error metrics: correlation, RMSE, and Percent Bias.
@@ -597,14 +613,14 @@ class RasUtils:
             >>> predicted = np.array([1.1, 2.2, 2.9])
             >>> RasUtils.calculate_error_metrics(observed, predicted)
             {'cor': 0.9993, 'rmse': 0.06396, 'pb': 0.03333}
-            
-        Attribution Note: This function is sourced from funkshuns.py by Sean Micek, and converted to the ras-commander style guide.
         """
         correlation = np.corrcoef(observed_values, predicted_values)[0, 1]
         rmse = RasUtils.calculate_rmse(observed_values, predicted_values)
         percent_bias = RasUtils.calculate_percent_bias(observed_values, predicted_values)
         
-        return {'cor': correlation, 'rmse': rmse, 'pb': percent_bias}
+        metrics = {'cor': correlation, 'rmse': rmse, 'pb': percent_bias}
+        logger.info(f"Calculated error metrics: {metrics}")
+        return metrics
 
 
 

ras_commander/__init__.py

@@ -1,4 +1,5 @@
 from importlib.metadata import version, PackageNotFoundError
+from .logging_config import setup_logging, get_logger, log_call
 
 try:
     __version__ = version("ras-commander")
@@ -6,6 +7,9 @@ except PackageNotFoundError:
     # package is not installed
     __version__ = "unknown"
 
+# Set up logging
+setup_logging()
+
 # Import all necessary functions and classes directly
 from .RasPrj import ras, init_ras_project, get_ras_exe
 from .RasPrj import RasPrj
@@ -15,17 +19,8 @@ from .RasUnsteady import RasUnsteady
 from .RasCmdr import RasCmdr
 from .RasUtils import RasUtils
 from .RasExamples import RasExamples
-from .RasHdf import RasHdf  # Add this line
-
-# Import all attributes from these modules
-from .RasPrj import *
-from .RasPlan import *
-from .RasGeo import *
-from .RasUnsteady import *
-from .RasCmdr import *
-from .RasUtils import *
-from .RasExamples import *
-from .RasHdf import *  # Add this line
+from .RasHdf import RasHdf
+from .RasGpt import RasGpt
 
 # Define __all__ to specify what should be imported when using "from ras_commander import *"
 __all__ = [
@@ -39,5 +34,8 @@ __all__ = [
     "RasCmdr",
     "RasUtils",
     "RasExamples",
-    "RasHdf"  # Add this line
-]
+    "RasHdf",
+    "RasGpt",
+    "get_logger",
+    "log_call"
+]