Update utils/error_handling.py

utils/error_handling.py

@@ -12,7 +12,90 @@ from utils.logging import get_logger, log_error
 
 # Initialize logger
 logger = get_logger(__name__)
+# utils/error_handling.py
+import streamlit as st
+import traceback
+from typing import Any, Callable
+import functools
+
+# Import your logging utilities
+from utils.logging import get_logger
+
+# Custom exception classes
+class DataError(Exception):
+    """Custom exception for data-related errors"""
+    pass
+
+class ValidationError(Exception):
+    """Custom exception for validation errors"""
+    pass
+
+# Get logger without passing __name__ if get_logger() doesn't accept arguments
+logger = get_logger()  # Remove __name__ argument
+
+def handle_data_exceptions(func: Callable) -> Callable:
+    """
+    Decorator to handle data-related exceptions gracefully
+    
+    Args:
+        func: Function to wrap with exception handling
+    
+    Returns:
+        Wrapped function with exception handling
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except (DataError, ValidationError) as e:
+            logger.error(f"Data handling error in {func.__name__}: {str(e)}")
+            st.error(f"Data Error: {str(e)}")
+            return None
+        except Exception as e:
+            logger.error(f"Unexpected error in {func.__name__}: {str(e)}")
+            logger.error(f"Traceback: {traceback.format_exc()}")
+            st.error(f"An unexpected error occurred: {str(e)}")
+            return None
+    
+    return wrapper
 
+def validate_data(data: Any, data_type: str) -> bool:
+    """
+    Validate data based on expected type
+    
+    Args:
+        data: Data to validate
+        data_type: Expected data type
+    
+    Returns:
+        bool: True if valid, False otherwise
+    
+    Raises:
+        ValidationError: If validation fails
+    """
+    if data is None:
+        raise ValidationError(f"Data cannot be None for type: {data_type}")
+    
+    if data_type == "dataframe":
+        import pandas as pd
+        if not isinstance(data, pd.DataFrame):
+            raise ValidationError("Expected pandas DataFrame")
+        if data.empty:
+            raise ValidationError("DataFrame cannot be empty")
+    
+    elif data_type == "list":
+        if not isinstance(data, list):
+            raise ValidationError("Expected list")
+        if len(data) == 0:
+            raise ValidationError("List cannot be empty")
+    
+    elif data_type == "dict":
+        if not isinstance(data, dict):
+            raise ValidationError("Expected dictionary")
+        if len(data) == 0:
+            raise ValidationError("Dictionary cannot be empty")
+    
+    return True
 
 # Custom exceptions
 class MonaError(Exception):