py-wlcli 0.8.0__py3-none-any.whl

wl_cli/utils/error_handler.py

@@ -0,0 +1,165 @@
+"""Unified error handling utilities for WL Commands."""
+
+import traceback
+from collections.abc import Callable
+from typing import Any, TypeVar, cast
+
+from ..exceptions import CommandError
+from .logging import log_error
+
+T = TypeVar("T")
+
+
+class ErrorHandler:
+    """Unified error handler for WL Commands."""
+
+    # Error message format constants
+    ERROR_FORMAT = "{error_type}: {error_message}"
+    ERROR_WITH_CONTEXT_FORMAT = "Error in {context}: {error_type} - {error_message}"
+    COMMAND_ERROR_FORMAT = "Command execution failed: {error_message}"
+
+    @staticmethod
+    def handle_error(
+        error: Exception, context: str | None = None, show_traceback: bool = False
+    ) -> None:
+        """
+        Handle an error with consistent formatting and logging.
+
+        Args:
+            error: The exception to handle
+            context: Optional context information about where the error occurred
+            show_traceback: Whether to show full traceback for debugging
+        """
+        error_type = type(error).__name__
+        error_message = str(error)
+
+        if context:
+            formatted_error = ErrorHandler.ERROR_WITH_CONTEXT_FORMAT.format(
+                context=context, error_type=error_type, error_message=error_message
+            )
+        else:
+            formatted_error = ErrorHandler.ERROR_FORMAT.format(
+                error_type=error_type, error_message=error_message
+            )
+
+        # Log the error with appropriate context
+        log_error(formatted_error, **ErrorHandler._get_error_context(error))
+
+        # Show traceback if requested
+        if show_traceback:
+            traceback.print_exc()
+
+    @staticmethod
+    def _get_error_context(error: Exception) -> dict[str, Any]:
+        """
+        Extract context information from the error object.
+
+        Args:
+            error: The exception to extract context from
+
+        Returns:
+            Dict with context information
+        """
+        context = {}
+        # Extract additional context from specific exception types
+        if hasattr(error, "path"):
+            context["path"] = error.path
+        if hasattr(error, "command"):
+            context["command"] = error.command
+        if hasattr(error, "url"):
+            context["url"] = error.url
+        if hasattr(error, "field"):
+            context["field"] = error.field
+        if hasattr(error, "error_code"):
+            context["error_code"] = error.error_code
+        return context
+
+    @staticmethod
+    def wrap_command_execution(func: Callable[..., T], *args: Any, **kwargs: Any) -> T:
+        """
+        Wrap command execution with error handling.
+
+        Args:
+            func: The function to execute
+            *args: Positional arguments to pass to the function
+            **kwargs: Keyword arguments to pass to the function
+
+        Returns:
+            The result of the function execution
+
+        Raises:
+            CommandError: If the function raises an exception
+        """
+        try:
+            return func(*args, **kwargs)
+        except CommandError:
+            # Re-raise CommandError as is
+            raise
+        except Exception as e:
+            # Wrap other exceptions in CommandError with standardized format
+            error_message = ErrorHandler.COMMAND_ERROR_FORMAT.format(
+                error_message=str(e)
+            )
+            raise CommandError(error_message) from e
+
+    @staticmethod
+    def global_exception_handler(func: Callable[..., T]) -> Callable[..., T]:
+        """
+        Global exception handler decorator for command functions.
+
+        Args:
+            func: The function to decorate
+
+        Returns:
+            The decorated function with global exception handling
+        """
+
+        def wrapper(*args: Any, **kwargs: Any) -> T:
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                # Handle all exceptions globally
+                ErrorHandler.handle_error(e, context=func.__name__)
+                # For CLI commands, we should return an error code
+                if func.__name__ == "main" or "cli" in func.__name__:
+                    return cast("T", 1)
+                raise
+
+        return wrapper
+
+    @staticmethod
+    def exception_to_dict(error: Exception) -> dict[str, Any]:
+        """
+        Convert an exception to a dictionary for structured logging.
+
+        Args:
+            error: The exception to convert
+
+        Returns:
+            Dict with exception information
+        """
+        return {
+            "error_type": type(error).__name__,
+            "error_message": str(error),
+            "error_code": getattr(error, "error_code", None),
+            **ErrorHandler._get_error_context(error),
+        }
+
+
+class ErrorContext:
+    """Context manager for error handling."""
+
+    def __init__(self, context: str, show_traceback: bool = False):
+        self.context = context
+        self.show_traceback = show_traceback
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is not None:
+            ErrorHandler.handle_error(
+                exc_val, self.context, show_traceback=self.show_traceback
+            )
+            return True  # Suppress the exception
+        return False

wl_cli/utils/file_copier.py

@@ -0,0 +1,56 @@
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class CopyResult:
+    success: bool
+    message: str = ""
+
+
+class FileCopier:
+    def copy_file(
+        self,
+        src: Path,
+        dest: Path,
+        template: bool = False,
+        context: dict[str, Any] | None = None,
+        overwrite: bool = False,
+    ) -> CopyResult:
+        try:
+            if not src.exists():
+                return CopyResult(False, f"Source file not found: {src}")
+
+            if dest.exists() and not overwrite:
+                return CopyResult(False, f"Destination already exists: {dest}")
+
+            dest.parent.mkdir(parents=True, exist_ok=True)
+
+            if template and context:
+                try:
+                    content = src.read_text(encoding="utf-8")
+                    content = content.format(**context)
+                    dest.write_text(content, encoding="utf-8")
+                except KeyError as e:
+                    return CopyResult(False, f"Missing template key: {e}")
+            else:
+                shutil.copy2(src, dest)
+
+            return CopyResult(True)
+        except Exception as e:
+            return CopyResult(False, str(e))
+
+    def copy_directory(self, src: Path, dest: Path) -> CopyResult:
+        try:
+            if not src.exists():
+                return CopyResult(False, f"Source directory not found: {src}")
+
+            if dest.exists():
+                shutil.rmtree(dest)
+
+            shutil.copytree(src, dest)
+            return CopyResult(True)
+        except Exception as e:
+            return CopyResult(False, str(e))