Update utils/error_handling.py

utils/error_handling.py

@@ -1,25 +1,9 @@
-"""
-Error handling module for the MONA application.
-
-This module provides standardized error handling patterns and custom exceptions
-for consistent error management across the application.
-"""
-
-import traceback
-from functools import wraps
-
-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
+from utils.logging import get_logger, log_error
 
 # Custom exception classes
 class DataError(Exception):
@@ -30,8 +14,8 @@ 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
+# Get logger
+logger = get_logger(__name__)
 
 def handle_data_exceptions(func: Callable) -> Callable:
     """
@@ -48,13 +32,14 @@ def handle_data_exceptions(func: Callable) -> Callable:
         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)}")
+            log_error(logger, f"Data handling error in {func.__name__}: {str(e)}")
+            # Instead of streamlit error, we'll raise the exception or return None
+            print(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)}")
+            log_error(logger, f"Unexpected error in {func.__name__}: {str(e)}")
+            log_error(logger, f"Traceback: {traceback.format_exc()}")
+            print(f"An unexpected error occurred: {str(e)}")
             return None
     
     return wrapper
@@ -77,11 +62,14 @@ def validate_data(data: Any, data_type: str) -> bool:
         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")
+        try:
+            import pandas as pd
+            if not isinstance(data, pd.DataFrame):
+                raise ValidationError("Expected pandas DataFrame")
+            if data.empty:
+                raise ValidationError("DataFrame cannot be empty")
+        except ImportError:
+            raise ValidationError("pandas not available for DataFrame validation")
     
     elif data_type == "list":
         if not isinstance(data, list):
@@ -97,264 +85,32 @@ def validate_data(data: Any, data_type: str) -> bool:
     
     return True
 
-# Custom exceptions
-class MonaError(Exception):
-    """Base exception class for all MONA application errors."""
-    def __init__(self, message, details=None):
-        self.message = message
-        self.details = details
-        super().__init__(self.message)
-
-
-class DataError(MonaError):
-    """Exception raised for errors related to data operations."""
-    pass
-
-
-class AIModelError(MonaError):
-    """Exception raised for errors related to AI model operations."""
-    pass
-
-
-class ValidationError(MonaError):
-    """Exception raised for validation errors."""
-    pass
-
-
-class IntegrationError(MonaError):
-    """Exception raised for errors related to external integrations."""
-    pass
-
-
-class ConfigurationError(MonaError):
-    """Exception raised for configuration errors."""
-    pass
-
-
-class UserInputError(MonaError):
-    """Exception raised for invalid user input."""
-    pass
-
-
-# Error handling decorators
-def handle_exceptions(func):
-    """
-    Decorator to handle exceptions in a standardized way.
-    
-    Args:
-        func (callable): The function to decorate.
-    
-    Returns:
-        callable: The decorated function.
-    """
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except MonaError as e:
-            # Log the custom exception
-            log_error(f"{type(e).__name__}: {e.message}", exc_info=e)
-            # Return a user-friendly error message
-            return {
-                "success": False,
-                "error": {
-                    "type": type(e).__name__,
-                    "message": e.message,
-                    "details": e.details
-                }
-            }
-        except Exception as e:
-            # Log unexpected exceptions
-            log_error(f"Unexpected error in {func.__name__}: {str(e)}", exc_info=e)
-            # Return a generic error message
-            return {
-                "success": False,
-                "error": {
-                    "type": "UnexpectedError",
-                    "message": "An unexpected error occurred. Please try again later.",
-                    "details": str(e) if __debug__ else None
-                }
-            }
-    return wrapper
-
-
-def handle_ui_exceptions(func):
+def show_error(message: str):
     """
-    Decorator to handle exceptions in UI components.
-    
-    Args:
-        func (callable): The function to decorate.
-    
-    Returns:
-        callable: The decorated function.
-    """
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except MonaError as e:
-            # Log the custom exception
-            log_error(f"UI Error - {type(e).__name__}: {e.message}", exc_info=e)
-            # Return a user-friendly error message for UI display
-            return f"Error: {e.message}"
-        except Exception as e:
-            # Log unexpected exceptions
-            log_error(f"Unexpected UI error in {func.__name__}: {str(e)}", exc_info=e)
-            # Return a generic error message for UI display
-            return "An unexpected error occurred. Please try again later."
-    return wrapper
-
-
-def handle_data_exceptions(func):
+    Display error message (streamlit-safe)
     """
-    Decorator to handle exceptions in data operations.
-    
-    Args:
-        func (callable): The function to decorate.
-    
-    Returns:
-        callable: The decorated function.
-    """
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except (FileNotFoundError, PermissionError, IOError) as e:
-            # Convert to custom exception
-            raise DataError(f"Data access error: {str(e)}", {
-                "original_error": str(e),
-                "traceback": traceback.format_exc()
-            }) from e
-        except Exception as e:
-            # Convert to custom exception
-            raise DataError(f"Unexpected data error: {str(e)}", {
-                "original_error": str(e),
-                "traceback": traceback.format_exc()
-            }) from e
-    return wrapper
-
-
-def handle_ai_model_exceptions(func):
-    """
-    Decorator to handle exceptions in AI model operations.
-    
-    Args:
-        func (callable): The function to decorate.
-    
-    Returns:
-        callable: The decorated function.
-    """
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except Exception as e:
-            # Convert to custom exception
-            raise AIModelError(f"AI model error: {str(e)}", {
-                "original_error": str(e),
-                "traceback": traceback.format_exc()
-            }) from e
-    return wrapper
-
-
-# Validation functions
-def validate_input(data, schema):
-    """
-    Validate input data against a schema.
-    
-    Args:
-        data (dict): The input data to validate.
-        schema (dict): The schema to validate against.
-    
-    Raises:
-        ValidationError: If validation fails.
-    """
-    errors = []
-    
-    # Check required fields
-    for field in schema.get("required", []):
-        if field not in data:
-            errors.append(f"Missing required field: {field}")
-    
-    # Check field types
-    for field, field_schema in schema.get("properties", {}).items():
-        if field in data and data[field] is not None:
-            expected_type = field_schema.get("type")
-            if expected_type == "string" and not isinstance(data[field], str):
-                errors.append(f"Field {field} must be a string")
-            elif expected_type == "number" and not isinstance(data[field], (int, float)):
-                errors.append(f"Field {field} must be a number")
-            elif expected_type == "integer" and not isinstance(data[field], int):
-                errors.append(f"Field {field} must be an integer")
-            elif expected_type == "boolean" and not isinstance(data[field], bool):
-                errors.append(f"Field {field} must be a boolean")
-            elif expected_type == "array" and not isinstance(data[field], list):
-                errors.append(f"Field {field} must be an array")
-            elif expected_type == "object" and not isinstance(data[field], dict):
-                errors.append(f"Field {field} must be an object")
-    
-    if errors:
-        raise ValidationError("Validation failed", {"errors": errors})
-
-
-def safe_get(dictionary, key, default=None):
-    """Safely get a value from dict/object with fallback."""
     try:
-        return dictionary[key]
-    except KeyError:
-        return default
-    """
-    Safely get a value from a nested dictionary.
-    
-    Args:
-        data (dict): The dictionary to get the value from.
-        path (str): The path to the value, using dot notation (e.g., "user.profile.name").
-        default: The default value to return if the path doesn't exist.
-    
-    Returns:
-        The value at the specified path, or the default value if the path doesn't exist.
-    """
-    keys = path.split('.')
-    result = data
-    
-    try:
-        for key in keys:
-            if isinstance(result, dict):
-                result = result.get(key, default)
-            else:
-                return default
-        return result
-    except Exception:
-        return default
-
+        import streamlit as st
+        st.error(message)
+    except ImportError:
+        print(f"ERROR: {message}")
 
-# Error formatting functions
-def format_error_for_user(error):
+def show_warning(message: str):
     """
-    Format an error for user display.
-    
-    Args:
-        error (Exception): The error to format.
-    
-    Returns:
-        str: A user-friendly error message.
+    Display warning message (streamlit-safe)
     """
-    if isinstance(error, MonaError):
-        return error.message
-    return "An unexpected error occurred. Please try again later."
-
+    try:
+        import streamlit as st
+        st.warning(message)
+    except ImportError:
+        print(f"WARNING: {message}")
 
-def format_error_for_log(error):
+def show_success(message: str):
     """
-    Format an error for logging.
-    
-    Args:
-        error (Exception): The error to format.
-    
-    Returns:
-        str: A detailed error message for logging.
+    Display success message (streamlit-safe)
     """
-    if isinstance(error, MonaError):
-        details = error.details if error.details else {}
-        return f"{type(error).__name__}: {error.message} - {details}"
-    return f"{type(error).__name__}: {str(error)}\n{traceback.format_exc()}"
+    try:
+        import streamlit as st
+        st.success(message)
+    except ImportError:
+        print(f"SUCCESS: {message}")