awesome-errors 0.3.0__tar.gz → 0.4.0__tar.gz

{awesome_errors-0.3.0 → awesome_errors-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: awesome-errors
-Version: 0.3.0
+Version: 0.4.0
 Summary: A comprehensive error handling library for Python applications with i18n support
 Project-URL: Homepage, https://github.com/THEROER/awesome-errors
 Project-URL: Repository, https://github.com/THEROER/awesome-errors
@@ -79,15 +79,14 @@ A comprehensive Python library for standardized error handling, analysis, and do
 
 - **FastAPI middleware**: `setup_error_handling`
 - **Litestar handlers**: `create_litestar_exception_handlers`
+- Both integrations share their translation, logging, and exception-mapping
+  logic via `middleware/_base.py`.
 
-#### 6. **Internationalization** (`src/awesome_errors/i18n/`)
+#### 7. **Internationalization** (`src/awesome_errors/i18n/`)
 
 - **ErrorTranslator**: Multi-language error message support
-- Locale files in `src/awesome_errors/i18n/locales/`
-
-#### 7. **Middleware** (`src/awesome_errors/middleware/`)
-
-- **setup_error_handling**: FastAPI error handling middleware
+- English defaults are built in; additional locales load from
+  `src/awesome_errors/i18n/locales/` (importing the library never writes to disk)
 
 ## Usage Examples
 

{awesome_errors-0.3.0 → awesome_errors-0.4.0}/README.md

@@ -45,15 +45,14 @@ A comprehensive Python library for standardized error handling, analysis, and do
 
 - **FastAPI middleware**: `setup_error_handling`
 - **Litestar handlers**: `create_litestar_exception_handlers`
+- Both integrations share their translation, logging, and exception-mapping
+  logic via `middleware/_base.py`.
 
-#### 6. **Internationalization** (`src/awesome_errors/i18n/`)
+#### 7. **Internationalization** (`src/awesome_errors/i18n/`)
 
 - **ErrorTranslator**: Multi-language error message support
-- Locale files in `src/awesome_errors/i18n/locales/`
-
-#### 7. **Middleware** (`src/awesome_errors/middleware/`)
-
-- **setup_error_handling**: FastAPI error handling middleware
+- English defaults are built in; additional locales load from
+  `src/awesome_errors/i18n/locales/` (importing the library never writes to disk)
 
 ## Usage Examples
 

{awesome_errors-0.3.0 → awesome_errors-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "awesome-errors"
-version = "0.3.0"
+version = "0.4.0"
 description = "A comprehensive error handling library for Python applications with i18n support"
 authors = [{ name = "THEROER", email = "theroer09@gmail.com" }]
 readme = "README.md"

{awesome_errors-0.3.0 → awesome_errors-0.4.0}/src/awesome_errors/__init__.py

@@ -162,9 +162,15 @@ def setup_websocket_error_handling(app: Any) -> Any:
     return _setup_websocket_error_handling(app)
 
 
-__version__ = "0.1.0"
+try:
+    from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+    __version__ = _pkg_version("awesome-errors")
+except PackageNotFoundError:  # pragma: no cover - source checkout without install
+    __version__ = "0.4.0"
 
 __all__ = [
+    "__version__",
     "AppError",
     "APIError",
     "ValidationError",

{awesome_errors-0.3.0 → awesome_errors-0.4.0}/src/awesome_errors/analysis/error_analyzer.py

@@ -1,10 +1,22 @@
 import ast
 import inspect
+import textwrap
 from typing import Set, List, Dict, Any, Optional, Callable
 
 
 class ErrorAnalyzer(ast.NodeVisitor):
-    """AST analyzer to find all possible errors in a function."""
+    """AST analyzer that discovers the error codes a function may raise.
+
+    The analysis is static: it parses the function's own source (and its
+    decorators) looking for ``raise`` statements and well-known library call
+    patterns. It does not follow calls into other functions — resolving call
+    targets reliably requires runtime introspection that isn't available from
+    the AST alone.
+
+    ``max_depth`` and ``analyze_decorators`` are accepted for backwards
+    compatibility; ``max_depth`` currently has no effect since cross-function
+    recursion is not performed.
+    """
 
     def __init__(
         self, function: Callable, max_depth: int = 10, analyze_decorators: bool = True
@@ -14,16 +26,14 @@ class ErrorAnalyzer(ast.NodeVisitor):
 
         Args:
             function: Function to analyze
-            max_depth: Maximum depth for recursive analysis
+            max_depth: Retained for compatibility (no cross-function recursion)
             analyze_decorators: Whether to analyze decorators
         """
         self.function = function
         self.max_depth = max_depth
         self.analyze_decorators = analyze_decorators
-        self.current_depth = 0
         self.errors: Set[str] = set()
         self.error_details: List[Dict[str, Any]] = []
-        self.visited_functions: Set[str] = set()
         self.decorator_errors: List[Dict[str, Any]] = []
 
     def analyze(self) -> Dict[str, Any]:
@@ -33,64 +43,57 @@ class ErrorAnalyzer(ast.NodeVisitor):
         Returns:
             Dictionary with error analysis results
         """
-        # Reset state
+        # Reset state so an analyzer can be reused.
         self.errors.clear()
         self.error_details.clear()
-        self.visited_functions.clear()
         self.decorator_errors.clear()
-        self.current_depth = 0
 
-        # Analyze decorators first
         if self.analyze_decorators:
             self._analyze_decorators(self.function)
 
-        # Analyze the main function
-        self._analyze_function(self.function, is_main=True)
+        self._analyze_function(self.function)
 
         return {
-            "function_name": self.function.__name__,
-            "error_codes": sorted(list(self.errors)),
+            "function_name": getattr(self.function, "__name__", "<unknown>"),
+            "error_codes": sorted(self.errors),
             "error_details": self.error_details,
             "decorator_errors": self.decorator_errors,
             "total_errors": len(self.errors),
-            "analysis_depth": self.current_depth,
-            "max_depth_reached": self.current_depth >= self.max_depth,
+            "analysis_depth": 0,
+            "max_depth_reached": False,
         }
 
-    def _analyze_function(self, func: Callable, is_main: bool = False) -> None:
-        """Analyze a specific function for errors with depth control."""
-        if self.current_depth >= self.max_depth and not is_main:
-            return
+    @staticmethod
+    def _get_source(func: Callable) -> Optional[str]:
+        """Return the dedented source of ``func``, or ``None`` if unavailable.
 
-        func_name = f"{func.__module__}.{func.__qualname__}"
+        Handles wrapped functions (``functools.wraps``) and environments where
+        ``inspect.getsource`` fails because the recorded filename can't be read.
+        """
+        target = inspect.unwrap(func)
+        for candidate in (target, func):
+            try:
+                return textwrap.dedent(inspect.getsource(candidate))
+            except (OSError, TypeError):
+                continue
+        return None
 
-        # Avoid infinite recursion
-        if func_name in self.visited_functions:
+    def _analyze_function(self, func: Callable) -> None:
+        """Parse a function's source and visit its AST for raised errors."""
+        source = self._get_source(func)
+        if source is None:
+            # Source unavailable (builtin/C function or unreadable file) — fall
+            # back to inferring errors from the callable's identity.
+            self._analyze_builtin_function(func)
             return
 
-        self.visited_functions.add(func_name)
-
-        if not is_main:
-            self.current_depth += 1
-
         try:
-            # Get function source and parse AST
-            source = inspect.getsource(func)
-            # Remove leading indentation to avoid IndentationError
-            import textwrap
-
-            source = textwrap.dedent(source)
             tree = ast.parse(source)
-
-            # Visit AST nodes
-            self.visit(tree)
-
-        except (OSError, TypeError):
-            # Can't get source - try to infer common library errors
+        except SyntaxError:
             self._analyze_builtin_function(func)
+            return
 
-        if not is_main:
-            self.current_depth -= 1
+        self.visit(tree)
 
     def visit_Raise(self, node: ast.Raise) -> None:
         """Handle raise statements."""
@@ -103,20 +106,8 @@ class ErrorAnalyzer(ast.NodeVisitor):
         self.generic_visit(node)
 
     def visit_Call(self, node: ast.Call) -> None:
-        """Enhanced call analysis with context-aware error detection."""
-        # Analyze call context for known error patterns
+        """Detect known error-producing call patterns (ORM/validation)."""
         self._analyze_call_context(node)
-
-        # Handle method calls (obj.method())
-        if isinstance(node.func, ast.Attribute):
-            self._analyze_method_call(node)
-
-        # Handle regular function calls
-        else:
-            called_func = self._resolve_function_call(node)
-            if called_func and self.current_depth < self.max_depth:
-                self._analyze_function(called_func)
-
         self.generic_visit(node)
 
     def _analyze_call_context(self, node: ast.Call) -> None:
@@ -152,10 +143,6 @@ class ErrorAnalyzer(ast.NodeVisitor):
         ):
             self.errors.add("VALIDATION_FAILED")
 
-        # Async operations
-        elif "await " in call_str:
-            self.errors.update(["INTERNAL_ERROR", "TIMEOUT_ERROR"])
-
     def _get_call_string(self, node: ast.Call) -> str:
         """Get string representation of call for pattern matching."""
         try:
@@ -404,14 +391,6 @@ class ErrorAnalyzer(ast.NodeVisitor):
         except Exception:
             pass
 
-    def _analyze_method_call(self, node: ast.Call) -> None:
-        """Analyze method calls by trying to resolve and analyze the actual method."""
-        if isinstance(node.func, ast.Attribute):
-            # Try to resolve the actual method and analyze it
-            resolved_method = self._resolve_method_call(node)
-            if resolved_method and self.current_depth < self.max_depth:
-                self._analyze_function(resolved_method)
-
     def _analyze_builtin_function(self, func: Callable) -> None:
         """Analyze built-in functions for common error patterns using existing converters."""
         func_name = getattr(func, "__name__", str(func))
@@ -435,9 +414,9 @@ class ErrorAnalyzer(ast.NodeVisitor):
         from ..core.error_codes import ErrorCode
 
         # Get all possible error codes from SQL converter patterns
-        sql_error_codes = set()
-        for pattern, (code, message) in SQLErrorConverter.SQL_PATTERNS.items():
-            sql_error_codes.add(code.value)
+        sql_error_codes = {
+            code.value for code, _message in SQLErrorConverter.SQL_PATTERNS.values()
+        }
 
         # Add common SQLAlchemy errors based on existing converter
         sql_error_codes.update(
@@ -449,15 +428,3 @@ class ErrorAnalyzer(ast.NodeVisitor):
         )
 
         self.errors.update(sql_error_codes)
-
-    def _resolve_method_call(self, node: ast.Call) -> Optional[Callable]:
-        """Try to resolve method call to actual method object."""
-        # For now, return None but analyze based on context
-        # This is complex and would require runtime introspection
-        return None
-
-    def _resolve_function_call(self, node: ast.Call) -> Optional[Callable]:
-        """Try to resolve function call to actual function object."""
-        # For now, return None but analyze based on context
-        # This is complex and would require runtime introspection
-        return None

{awesome_errors-0.3.0 → awesome_errors-0.4.0}/src/awesome_errors/converters/sql_converter.py

@@ -128,9 +128,6 @@ class SQLErrorConverter:
                 elif code == ErrorCode.DB_INVALID_REFERENCE and field_name:
                     db_error.message = f"{message} in field: {field_name}"
 
-                if db_error.details.get("table"):
-                    db_error.details["table"] = db_error.details["table"]
-
                 return db_error
 
         # Default integrity error

{awesome_errors-0.3.0 → awesome_errors-0.4.0}/src/awesome_errors/converters/universal_converter.py

@@ -1,4 +1,8 @@
-from typing import Any, Optional
+import json
+from typing import TYPE_CHECKING, Optional, cast
+
+if TYPE_CHECKING:
+    from pydantic import ValidationError as PydanticValidationError
 
 from ..core.error_codes import ErrorCode
 from ..core.exceptions import AppError
@@ -22,14 +26,6 @@ except ImportError:  # pragma: no cover
 else:  # pragma: no cover
     PydanticValidationErrorType = _LoadedPydanticValidationError
 
-_PydanticErrorConverter: Any = None
-try:  # pragma: no cover - optional dependency
-    from .pydantic_converter import PydanticErrorConverter as _LoadedPydanticErrorConverter
-except ImportError:  # pragma: no cover
-    pass
-else:  # pragma: no cover
-    _PydanticErrorConverter = _LoadedPydanticErrorConverter
-
 
 class UniversalErrorConverter:
     """Universal error converter that handles any type of exception."""
@@ -54,11 +50,11 @@ class UniversalErrorConverter:
         if PydanticValidationErrorType is not None and isinstance(
             error, PydanticValidationErrorType
         ):
-            if _PydanticErrorConverter is None:
-                raise ImportError(
-                    "Install 'awesome-errors[pydantic]' to convert Pydantic validation errors."
-                ) from None
-            return _PydanticErrorConverter.convert(error)
+            from .pydantic_converter import PydanticErrorConverter
+
+            return PydanticErrorConverter.convert(
+                cast("PydanticValidationError", error)
+            )
 
         # SQLAlchemy errors
         if SQLAlchemyErrorType is not None and isinstance(error, SQLAlchemyErrorType):
@@ -78,46 +74,37 @@ class UniversalErrorConverter:
 
     @classmethod
     def _handle_special_cases(cls, error: Exception) -> Optional[AppError]:
-        """Handle special error cases."""
+        """Handle special error cases from the standard library and popular
+        third-party packages that are not covered by the dedicated converters."""
         error_type = type(error).__name__
         error_str = str(error)
 
-        # Handle HTTP-related errors
-        if "HTTPError" in error_type:
+        # JSON decode errors (subclass of ValueError; check before generic HTTP)
+        if isinstance(error, json.JSONDecodeError):
             return AppError(
-                code=ErrorCode.INTERNAL_ERROR,
-                message="HTTP request failed",
+                code=ErrorCode.INVALID_FORMAT,
+                message="Invalid JSON format",
                 details={"error_type": error_type, "error": error_str},
             )
 
-        # Handle JSON errors
-        if "JSONDecodeError" in error_type:
+        # HTTP client errors (requests/httpx/urllib) are matched by name so we
+        # don't have to import those optional packages just to identify them.
+        if "HTTPError" in error_type:
             return AppError(
-                code=ErrorCode.INVALID_FORMAT,
-                message="Invalid JSON format",
+                code=ErrorCode.INTERNAL_ERROR,
+                message="HTTP request failed",
                 details={"error_type": error_type, "error": error_str},
             )
 
-        # Handle import errors
+        # Missing modules
         if isinstance(error, (ImportError, ModuleNotFoundError)):
             return AppError(
                 code=ErrorCode.INTERNAL_ERROR,
                 message="Missing required module",
                 details={
-                    "module": error.name if hasattr(error, "name") else "unknown",
+                    "module": getattr(error, "name", None) or "unknown",
                     "error": error_str,
                 },
             )
 
         return None
-
-    @staticmethod
-    def _is_serializable(value: Any) -> bool:
-        """Check if value can be safely serialized."""
-        try:
-            import json
-
-            json.dumps(value)
-            return True
-        except Exception:
-            return False

awesome_errors-0.4.0/src/awesome_errors/core/_utils.py

@@ -0,0 +1,24 @@
+"""Shared internal helpers for the core package."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+
+def utc_now() -> datetime:
+    """Return the current time as a timezone-aware UTC ``datetime``."""
+    return datetime.now(timezone.utc)
+
+
+def to_iso_z(value: datetime) -> str:
+    """Render a ``datetime`` as an ISO-8601 string with a ``Z`` UTC suffix.
+
+    Naive datetimes are assumed to be UTC. Aware datetimes are converted to
+    UTC. The result always ends in ``Z`` and never contains a ``+00:00``
+    offset, giving a single canonical timestamp format across the library.
+    """
+    if value.tzinfo is None:
+        value = value.replace(tzinfo=timezone.utc)
+    else:
+        value = value.astimezone(timezone.utc)
+    return value.isoformat().replace("+00:00", "Z")

{awesome_errors-0.3.0 → awesome_errors-0.4.0}/src/awesome_errors/core/error_response.py

@@ -2,14 +2,12 @@
 
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import Any, Dict, Mapping
 
 import msgspec
 
-
-def _now_utc() -> datetime:
-    return datetime.now(timezone.utc)
+from ._utils import to_iso_z, utc_now
 
 
 class ErrorDetail(msgspec.Struct, kw_only=True, omit_defaults=True):
@@ -19,18 +17,18 @@ class ErrorDetail(msgspec.Struct, kw_only=True, omit_defaults=True):
     message: str
     request_id: str
     details: Dict[str, Any] = msgspec.field(default_factory=dict)
-    timestamp: datetime = msgspec.field(default_factory=_now_utc)
+    timestamp: datetime = msgspec.field(default_factory=utc_now)
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to builtin types, ensuring ISO timestamps."""
         data = msgspec.to_builtins(self, builtin_types=None)
         timestamp = data.get("timestamp")
         if isinstance(timestamp, datetime):
-            data["timestamp"] = timestamp.isoformat().replace("+00:00", "Z")
+            data["timestamp"] = to_iso_z(timestamp)
         elif isinstance(timestamp, str):
             data["timestamp"] = timestamp
         else:
-            data["timestamp"] = _now_utc().isoformat().replace("+00:00", "Z")
+            data["timestamp"] = to_iso_z(utc_now())
         return data
 
 
@@ -50,12 +48,12 @@ def error_detail_from_mapping(data: Mapping[str, Any]) -> ErrorDetail:
         try:
             timestamp = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
         except ValueError:
-            timestamp = _now_utc()
+            timestamp = utc_now()
 
     return ErrorDetail(
         code=str(data.get("code", "UNKNOWN_ERROR")),
         message=str(data.get("message", "")),
         details=dict(data.get("details") or {}),
-        timestamp=timestamp if isinstance(timestamp, datetime) else _now_utc(),
+        timestamp=timestamp if isinstance(timestamp, datetime) else utc_now(),
         request_id=str(data.get("request_id", "")),
     )

{awesome_errors-0.3.0 → awesome_errors-0.4.0}/src/awesome_errors/core/exceptions.py

@@ -1,7 +1,8 @@
 from typing import Any, ClassVar, Dict, Optional, Union, TYPE_CHECKING
-from datetime import datetime, timezone
+from datetime import datetime
 import uuid
 
+from ._utils import to_iso_z, utc_now
 from .error_codes import ErrorCode, get_http_status
 
 if TYPE_CHECKING:
@@ -41,7 +42,7 @@ class AppError(Exception):
         self.code = code if isinstance(code, ErrorCode) else ErrorCode(code)
         self.message = message
         self.details = details or {}
-        self.timestamp = datetime.now(timezone.utc)
+        self.timestamp = utc_now()
         self.request_id = str(uuid.uuid4())
 
         # Use provided status code or get from mapping
@@ -54,7 +55,7 @@ class AppError(Exception):
                 "code": self.code.value,
                 "message": self.message,
                 "details": self.details,
-                "timestamp": self.timestamp.isoformat() + "Z",
+                "timestamp": to_iso_z(self.timestamp),
                 "request_id": self.request_id,
             }
         }

{awesome_errors-0.3.0 → awesome_errors-0.4.0}/src/awesome_errors/core/renderers.py

@@ -7,20 +7,10 @@ from enum import StrEnum
 from typing import Any, Callable, Dict, Optional
 
 from ..core.exceptions import AppError
+from ._utils import to_iso_z
 from .error_response import ErrorDetail, ErrorResponse
 
 
-from datetime import timezone
-
-
-def _isoformat(dt):
-    if dt.tzinfo is None:
-        dt = dt.replace(tzinfo=timezone.utc)
-    else:
-        dt = dt.astimezone(timezone.utc)
-    return dt.isoformat().replace("+00:00", "Z")
-
-
 class ErrorResponseFormat(StrEnum):
     """Supported HTTP error payload shapes."""
 
@@ -97,7 +87,7 @@ class ErrorResponseRenderer:
             "detail": message,
             "instance": instance,
             "code": error.code.value,
-            "timestamp": _isoformat(error.timestamp),
+            "timestamp": to_iso_z(error.timestamp),
             "request_id": error.request_id,
             "details": error.details,
         }