Update utils/error_handling.py

utils/error_handling.py

@@ -1,336 +1,277 @@
 """
-Error handling utilities for the application.
+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 functools
 import traceback
-from typing import Any, Callable, Dict, Optional, Type, Union
+from functools import wraps
+
 from utils.logging import get_logger, log_error
 
-# Custom Exception Classes
-class DataError(Exception):
-    """Base exception for data-related errors."""
-    def __init__(self, message: str, code: str = None, details: Dict[str, Any] = None):
-        super().__init__(message)
-        self.code = code
-        self.details = details or {}
-
-class ValidationError(DataError):
-    """Exception raised when data validation fails."""
-    def __init__(self, message: str, field: str = None, value: Any = None, code: str = "VALIDATION_ERROR"):
-        super().__init__(message, code)
-        self.field = field
-        self.value = value
-        if field:
-            self.details["field"] = field
-        if value is not None:
-            self.details["value"] = value
-
-class StorageError(DataError):
-    """Exception raised for storage-related errors."""
-    def __init__(self, message: str, operation: str = None, code: str = "STORAGE_ERROR"):
-        super().__init__(message, code)
-        self.operation = operation
-        if operation:
-            self.details["operation"] = operation
-
-class ConfigurationError(Exception):
-    """Exception raised for configuration-related errors."""
-    def __init__(self, message: str, config_key: str = None):
-        super().__init__(message)
-        self.config_key = config_key
-
-class APIError(Exception):
-    """Exception raised for API-related errors."""
-    def __init__(self, message: str, status_code: int = None, response_data: Dict = None):
-        super().__init__(message)
-        self.status_code = status_code
-        self.response_data = response_data or {}
-
-# Error Handler Decorator
-def handle_data_exceptions(
-    default_return: Any = None,
-    re_raise: bool = False,
-    log_errors: bool = True,
-    logger = None
-):
+# Initialize logger
+logger = get_logger(__name__)
+
+
+# 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 data-related exceptions.
+    Decorator to handle exceptions in a standardized way.
     
     Args:
-        default_return: Value to return if an exception occurs
-        re_raise: Whether to re-raise the exception after handling
-        log_errors: Whether to log errors
-        logger: Logger instance to use
+        func (callable): The function to decorate.
     
     Returns:
-        Decorated function
+        callable: The decorated function.
     """
-    def decorator(func: Callable) -> Callable:
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            try:
-                return func(*args, **kwargs)
-            except (DataError, ValidationError, StorageError) as e:
-                if log_errors:
-                    error_logger = logger or get_logger()
-                    log_error(e, f"Data exception in {func.__name__}", error_logger)
-                
-                if re_raise:
-                    raise
-                return default_return
-            except Exception as e:
-                if log_errors:
-                    error_logger = logger or get_logger()
-                    log_error(e, f"Unexpected exception in {func.__name__}", error_logger)
-                
-                if re_raise:
-                    raise
-                return default_return
-        return wrapper
-    return decorator
-
-def handle_exceptions(
-    exceptions: Union[Type[Exception], tuple] = Exception,
-    default_return: Any = None,
-    log_errors: bool = True,
-    logger = None
-):
+    @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):
     """
-    Generic exception handler decorator.
+    Decorator to handle exceptions in UI components.
     
     Args:
-        exceptions: Exception type(s) to catch
-        default_return: Value to return if an exception occurs
-        log_errors: Whether to log errors
-        logger: Logger instance to use
+        func (callable): The function to decorate.
     
     Returns:
-        Decorated function
+        callable: The decorated function.
     """
-    def decorator(func: Callable) -> Callable:
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            try:
-                return func(*args, **kwargs)
-            except exceptions as e:
-                if log_errors:
-                    error_logger = logger or get_logger()
-                    log_error(e, f"Exception in {func.__name__}", error_logger)
-                return default_return
-        return wrapper
-    return decorator
-
-# Error Context Manager
-class ErrorHandler:
-    """Context manager for handling errors."""
-    
-    def __init__(self, 
-                 default_return: Any = None,
-                 log_errors: bool = True,
-                 logger = None,
-                 suppress: bool = True):
-        self.default_return = default_return
-        self.log_errors = log_errors
-        self.logger = logger or get_logger()
-        self.suppress = suppress
-        self.exception = None
-        self.return_value = None
-    
-    def __enter__(self):
-        return self
-    
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if exc_type is not None:
-            self.exception = exc_val
-            
-            if self.log_errors:
-                log_error(exc_val, "Exception in ErrorHandler context", self.logger)
-            
-            self.return_value = self.default_return
-            return self.suppress
-        return False
-
-# Validation Functions
-def validate_required_fields(data: Dict[str, Any], required_fields: list) -> None:
+    @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):
     """
-    Validate that all required fields are present in data.
+    Decorator to handle exceptions in data operations.
     
     Args:
-        data: Dictionary to validate
-        required_fields: List of required field names
+        func (callable): The function to decorate.
     
-    Raises:
-        ValidationError: If any required field is missing
+    Returns:
+        callable: The decorated function.
     """
-    missing_fields = [field for field in required_fields if field not in data or data[field] is None]
-    
-    if missing_fields:
-        raise ValidationError(
-            f"Missing required fields: {', '.join(missing_fields)}",
-            code="MISSING_REQUIRED_FIELDS"
-        )
+    @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 validate_data_types(data: Dict[str, Any], type_mapping: Dict[str, type]) -> None:
+
+def handle_ai_model_exceptions(func):
     """
-    Validate data types for specified fields.
+    Decorator to handle exceptions in AI model operations.
     
     Args:
-        data: Dictionary to validate
-        type_mapping: Dictionary mapping field names to expected types
+        func (callable): The function to decorate.
     
-    Raises:
-        ValidationError: If any field has incorrect type
+    Returns:
+        callable: The decorated function.
     """
-    for field, expected_type in type_mapping.items():
-        if field in data and data[field] is not None:
-            if not isinstance(data[field], expected_type):
-                raise ValidationError(
-                    f"Field '{field}' must be of type {expected_type.__name__}, got {type(data[field]).__name__}",
-                    field=field,
-                    value=data[field],
-                    code="INVALID_TYPE"
-                )
-
-def validate_field_length(data: Dict[str, Any], length_constraints: Dict[str, Dict[str, int]]) -> None:
+    @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 field lengths against constraints.
+    Validate input data against a schema.
     
     Args:
-        data: Dictionary to validate
-        length_constraints: Dictionary mapping field names to length constraints
-                          e.g., {"name": {"min": 1, "max": 100}}
+        data (dict): The input data to validate.
+        schema (dict): The schema to validate against.
     
     Raises:
-        ValidationError: If any field violates length constraints
+        ValidationError: If validation fails.
     """
-    for field, constraints in length_constraints.items():
+    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:
-            value = data[field]
-            if hasattr(value, '__len__'):
-                length = len(value)
-                
-                if 'min' in constraints and length < constraints['min']:
-                    raise ValidationError(
-                        f"Field '{field}' must be at least {constraints['min']} characters long",
-                        field=field,
-                        value=value,
-                        code="TOO_SHORT"
-                    )
-                
-                if 'max' in constraints and length > constraints['max']:
-                    raise ValidationError(
-                        f"Field '{field}' must be at most {constraints['max']} characters long",
-                        field=field,
-                        value=value,
-                        code="TOO_LONG"
-                    )
-
-# Error Reporting
-def format_error_response(error: Exception, include_traceback: bool = False) -> Dict[str, Any]:
+            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
     """
-    Format an error for API response.
+    Safely get a value from a nested dictionary.
     
     Args:
-        error: Exception instance
-        include_traceback: Whether to include traceback
+        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:
-        Dictionary containing error information
+        The value at the specified path, or the default value if the path doesn't exist.
     """
-    response = {
-        "error": True,
-        "error_type": type(error).__name__,
-        "message": str(error)
-    }
-    
-    # Add custom error details
-    if hasattr(error, 'code'):
-        response["code"] = error.code
-    
-    if hasattr(error, 'details'):
-        response["details"] = error.details
+    keys = path.split('.')
+    result = data
     
-    if hasattr(error, 'status_code'):
-        response["status_code"] = error.status_code
-    
-    if include_traceback:
-        response["traceback"] = traceback.format_exc()
-    
-    return response
+    try:
+        for key in keys:
+            if isinstance(result, dict):
+                result = result.get(key, default)
+            else:
+                return default
+        return result
+    except Exception:
+        return default
 
-def safe_execute(func: Callable, *args, default_return: Any = None, **kwargs) -> Any:
+
+# Error formatting functions
+def format_error_for_user(error):
     """
-    Safely execute a function and return default value on error.
+    Format an error for user display.
     
     Args:
-        func: Function to execute
-        *args: Positional arguments for the function
-        default_return: Value to return on error
-        **kwargs: Keyword arguments for the function
+        error (Exception): The error to format.
     
     Returns:
-        Function result or default_return on error
+        str: A user-friendly error message.
     """
-    try:
-        return func(*args, **kwargs)
-    except Exception as e:
-        logger = get_logger()
-        log_error(e, f"Error in safe_execute for {func.__name__}", logger)
-        return default_return
-
-# Retry mechanism
-def retry_on_exception(
-    max_attempts: int = 3,
-    delay: float = 1.0,
-    exceptions: tuple = (Exception,),
-    backoff_factor: float = 2.0
-):
+    if isinstance(error, MonaError):
+        return error.message
+    return "An unexpected error occurred. Please try again later."
+
+
+def format_error_for_log(error):
     """
-    Decorator to retry function execution on specified exceptions.
+    Format an error for logging.
     
     Args:
-        max_attempts: Maximum number of retry attempts
-        delay: Initial delay between retries (seconds)
-        exceptions: Tuple of exception types to retry on
-        backoff_factor: Factor to multiply delay by for each retry
+        error (Exception): The error to format.
     
     Returns:
-        Decorated function
+        str: A detailed error message for logging.
     """
-    def decorator(func: Callable) -> Callable:
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            last_exception = None
-            current_delay = delay
-            
-            for attempt in range(max_attempts):
-                try:
-                    return func(*args, **kwargs)
-                except exceptions as e:
-                    last_exception = e
-                    
-                    if attempt < max_attempts - 1:  # Don't sleep on last attempt
-                        logger = get_logger()
-                        logger.warning(f"Attempt {attempt + 1} failed for {func.__name__}: {e}. Retrying in {current_delay}s...")
-                        
-                        import time
-                        time.sleep(current_delay)
-                        current_delay *= backoff_factor
-                    else:
-                        logger = get_logger()
-                        log_error(e, f"All {max_attempts} attempts failed for {func.__name__}", logger)
-            
-            # Re-raise the last exception if all attempts failed
-            raise last_exception
-        return wrapper
-    return decorator
-    def safe_get(obj, key, default=None):
-    """Safely get a value from dict/object with fallback."""
-    try:
-        if isinstance(obj, dict):
-            return obj.get(key, default)
-        else:
-            return getattr(obj, key, default)
-    except (AttributeError, KeyError, TypeError):
-        return default
+    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()}"