Update utils/error_handling.py

utils/error_handling.py

@@ -1,56 +1,133 @@
+"""
+Error handling utilities for the application
+"""
 import logging
-import sys
-from datetime import datetime
-from pathlib import Path
-
-# Global logger configuration
-LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-LOG_LEVEL = logging.INFO
-
-def setup_logging(log_level=LOG_LEVEL):
-    """Setup logging configuration"""
-    logging.basicConfig(
-        level=log_level,
-        format=LOG_FORMAT,
-        handlers=[
-            logging.StreamHandler(sys.stdout),
-        ]
-    )
-
-def get_logger(name):
-    """Get a logger instance"""
-    return logging.getLogger(name)
-
-def log_error(logger, error_msg, exception=None, context=None):
-    """Log error with additional context"""
-    full_msg = f"{error_msg}"
-    if context:
-        full_msg += f" | Context: {context}"
-    if exception:
-        full_msg += f" | Exception: {str(exception)}"
-    
-    logger.error(full_msg)
+import traceback
+from functools import wraps
+from typing import Any, Callable, Optional, Union
+import streamlit as st
 
-def log_info(logger, msg, context=None):
-    """Log info with additional context"""
-    full_msg = f"{msg}"
-    if context:
-        full_msg += f" | Context: {context}"
-    
-    logger.info(full_msg)
 
-def log_warning(logger, msg, context=None):
-    """Log warning with additional context"""
-    full_msg = f"{msg}"
-    if context:
-        full_msg += f" | Context: {context}"
-    
-    logger.warning(full_msg)
+class DataError(Exception):
+    """Custom exception for data-related errors"""
+    pass
+
+
+class ValidationError(Exception):
+    """Custom exception for validation errors"""
+    pass
+
+
+class ProcessingError(Exception):
+    """Custom exception for processing errors"""
+    pass
+
+
+def handle_data_exceptions(func: Callable) -> Callable:
+    """
+    Decorator to handle data-related exceptions
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except (DataError, ValidationError, ProcessingError) as e:
+            logging.error(f"Data error in {func.__name__}: {str(e)}")
+            st.error(f"Data error: {str(e)}")
+            return None
+        except FileNotFoundError as e:
+            logging.error(f"File not found in {func.__name__}: {str(e)}")
+            st.error(f"File not found: {str(e)}")
+            return None
+        except PermissionError as e:
+            logging.error(f"Permission error in {func.__name__}: {str(e)}")
+            st.error(f"Permission error: {str(e)}")
+            return None
+        except Exception as e:
+            logging.error(f"Unexpected error in {func.__name__}: {str(e)}")
+            logging.error(traceback.format_exc())
+            st.error(f"An unexpected error occurred: {str(e)}")
+            return None
+    return wrapper
+
+
+def handle_api_exceptions(func: Callable) -> Callable:
+    """
+    Decorator to handle API-related exceptions
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except ConnectionError as e:
+            logging.error(f"Connection error in {func.__name__}: {str(e)}")
+            st.error("Connection error. Please check your internet connection.")
+            return None
+        except TimeoutError as e:
+            logging.error(f"Timeout error in {func.__name__}: {str(e)}")
+            st.error("Request timed out. Please try again.")
+            return None
+        except Exception as e:
+            logging.error(f"API error in {func.__name__}: {str(e)}")
+            st.error(f"API error: {str(e)}")
+            return None
+    return wrapper
 
-def log_debug(logger, msg, context=None):
-    """Log debug with additional context"""
-    full_msg = f"{msg}"
-    if context:
-        full_msg += f" | Context: {context}"
+
+def log_error(message: str, error: Optional[Exception] = None):
+    """
+    Log an error message with optional exception details
+    """
+    if error:
+        logging.error(f"{message}: {str(error)}")
+        logging.error(traceback.format_exc())
+    else:
+        logging.error(message)
+
+
+def display_error(message: str, error_type: str = "error"):
+    """
+    Display an error message in the Streamlit interface
+    """
+    if error_type == "warning":
+        st.warning(message)
+    elif error_type == "info":
+        st.info(message)
+    else:
+        st.error(message)
+
+
+def validate_input(value: Any, value_type: type, field_name: str) -> bool:
+    """
+    Validate input value and type
+    """
+    if value is None:
+        raise ValidationError(f"{field_name} cannot be None")
     
-    logger.debug(full_msg)
+    if not isinstance(value, value_type):
+        raise ValidationError(f"{field_name} must be of type {value_type.__name__}")
+    
+    return True
+
+
+def safe_execute(func: Callable, *args, **kwargs) -> tuple[bool, Any]:
+    """
+    Safely execute a function and return success status and result
+    """
+    try:
+        result = func(*args, **kwargs)
+        return True, result
+    except Exception as e:
+        log_error(f"Error executing {func.__name__}", e)
+        return False, str(e)
+
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('app.log'),
+        logging.StreamHandler()
+    ]
+)