Amending ellar exception module refactor

Author: eadwinCode

ellar/common/decorators/controller.py

@@ -13,8 +13,8 @@
 )
 from ellar.core import ControllerBase
 from ellar.core.controller import ControllerType
+from ellar.core.exceptions import ImproperConfiguration
 from ellar.di import RequestScope, injectable
-from ellar.exceptions import ImproperConfiguration
 from ellar.reflect import reflect
 
 if t.TYPE_CHECKING:  # pragma: no cover

ellar/common/decorators/exception.py

@@ -7,12 +7,12 @@
 
 class ValidateExceptionHandler(BaseModel):
     key: t.Union[int, t.Type[Exception]]
-    value: t.Callable
+    value: t.Union[t.Callable, t.Type]
 
 
-def add_exception_handler(
+def _add_exception_handler(
     exc_class_or_status_code: t.Union[int, t.Type[Exception]],
-    handler: t.Callable,
+    handler: t.Union[t.Callable, t.Type],
 ) -> None:
     validator = ValidateExceptionHandler(key=exc_class_or_status_code, value=handler)
     exception_handlers = {validator.key: validator.value}
@@ -30,8 +30,8 @@ def exception_handler(
     :return: Function
     """
 
-    def decorator(func: t.Callable) -> t.Callable:
-        add_exception_handler(exc_class_or_status_code, func)
+    def decorator(func: t.Union[t.Callable, t.Type]) -> t.Callable:
+        _add_exception_handler(exc_class_or_status_code, func)
         return func
 
     return decorator

ellar/common/decorators/html.py

@@ -9,10 +9,10 @@
     TEMPLATE_FILTER_KEY,
     TEMPLATE_GLOBAL_KEY,
 )
+from ellar.core.exceptions import ImproperConfiguration
 from ellar.core.response.model import HTMLResponseModel
 from ellar.core.routing import RouteOperationBase
 from ellar.core.templating import TemplateFunctionData
-from ellar.exceptions import ImproperConfiguration
 from ellar.helper import class_base_function_regex, get_name
 from ellar.types import TemplateFilterCallable, TemplateGlobalCallable
 

ellar/common/decorators/modules.py

@@ -8,10 +8,10 @@
 from ellar.compatible import AttributeDict
 from ellar.constants import MODULE_METADATA, MODULE_WATERMARK
 from ellar.core import ControllerBase
+from ellar.core.exceptions import ImproperConfiguration
 from ellar.core.modules.base import ModuleBase, ModuleBaseMeta
 from ellar.core.routing import ModuleMount, ModuleRouter
 from ellar.di import ProviderConfig, SingletonScope, injectable
-from ellar.exceptions import ImproperConfiguration
 from ellar.reflect import reflect
 
 if t.TYPE_CHECKING:  # pragma: no cover

ellar/constants.py

@@ -51,7 +51,7 @@ def __new__(mcls, name, bases, namespace):
 OPENAPI_KEY = "OPENAPI"
 VERSIONING_KEY = "ROUTE_VERSIONING"
 GUARDS_KEY = "ROUTE_GUARDS"
-EXTRA_ROUTE_ARGS_KEY = "EXTRA_ROUTE_ARGSextra_route_args"
+EXTRA_ROUTE_ARGS_KEY = "EXTRA_ROUTE_ARGS"
 RESPONSE_OVERRIDE_KEY = "RESPONSE_OVERRIDE"
 EXCEPTION_HANDLERS_KEY = "EXCEPTION_HANDLERS"
 

ellar/core/guard/base.py

@@ -7,7 +7,7 @@
 
 from ellar.core.connection import HTTPConnection
 from ellar.core.context import ExecutionContext
-from ellar.exceptions import APIException
+from ellar.core.exceptions import APIException
 
 
 class GuardCanActivate(ABC, metaclass=ABCMeta):

ellar/core/guard/http.py

@@ -4,7 +4,7 @@
 from base64 import b64decode
 
 from ellar.core.connection import HTTPConnection
-from ellar.exceptions import APIException, AuthenticationFailed
+from ellar.core.exceptions import APIException, AuthenticationFailed
 
 from .base import BaseHttpAuth, HTTPAuthorizationCredentials, HTTPBasicCredentials
 

ellar/core/middleware/__init__.py

@@ -1,5 +1,3 @@
-import sys
-
 from starlette.middleware import Middleware as Middleware
 from starlette.middleware.authentication import AuthenticationMiddleware
 from starlette.middleware.base import BaseHTTPMiddleware
@@ -15,14 +13,9 @@
 from starlette.middleware.wsgi import WSGIMiddleware as WSGIMiddleware
 
 from .di import RequestServiceProviderMiddleware
+from .exceptions import ExceptionMiddleware
 from .versioning import RequestVersioningMiddleware
 
-if sys.version_info >= (3, 7):  # pragma: no cover
-    from starlette.middleware.exceptions import ExceptionMiddleware
-else:
-    from starlette.exceptions import ExceptionMiddleware
-
-
 __all__ = [
     "Middleware",
     "AuthenticationMiddleware",

ellar/core/middleware/di.py

@@ -16,6 +16,7 @@
 from ellar.types import ASGIApp, TReceive, TScope, TSend
 
 if t.TYPE_CHECKING:  # pragma: no cover
+    from ellar.core.exceptions.interfaces import IExceptionHandler
     from ellar.di.injector import EllarInjector, RequestServiceProvider
 
 
@@ -26,10 +27,14 @@ def __init__(
         *,
         debug: bool,
         injector: "EllarInjector",
-        handler: t.Callable = None
+        handler: "IExceptionHandler" = None
     ) -> None:
+        _handler = None
+        if handler:
+            self._500_error_handler = handler
+            _handler = self.error_handler
         super(RequestServiceProviderMiddleware, self).__init__(
-            debug=debug, handler=handler, app=app
+            debug=debug, handler=_handler, app=app
         )
         self.injector = injector
 
@@ -96,3 +101,9 @@ async def __call__(self, scope: TScope, receive: TReceive, send: TSend) -> None:
             scope[SCOPE_SERVICE_PROVIDER] = request_provider
             scope[SCOPE_EXECUTION_CONTEXT_PROVIDER] = execute_context
             await super().__call__(scope, receive, send)
+
+    async def error_handler(self, request: Request, exc: Exception) -> Response:
+        execute_context = request.scope[SCOPE_EXECUTION_CONTEXT_PROVIDER]
+        assert self._500_error_handler
+        response = await self._500_error_handler.catch(ctx=execute_context, exc=exc)
+        return response

ellar/core/modules/builder.py

@@ -12,6 +12,7 @@
 from ellar.core.events import EventHandler
 from ellar.reflect import reflect
 
+from ..exceptions.callable_exceptions import CallableExceptionHandler
 from .helper import class_parameter_executor_wrapper
 
 if t.TYPE_CHECKING:  # pragma: no cover
@@ -42,8 +43,12 @@ def __init__(self, cls: t.Union[t.Type["ModuleBase"], "ModuleBaseMeta"]) -> None
 
     def exception_config(self, exception_dict: t.Dict) -> None:
         for k, v in exception_dict.items():
-            func = class_parameter_executor_wrapper(self._cls, v)
-            reflect.define_metadata(EXCEPTION_HANDLERS_KEY, {k: func}, self._cls)
+            func = CallableExceptionHandler(
+                self._cls, callable_exception_handler=v, exc_class_or_status_code=k
+            )
+            reflect.define_metadata(
+                EXCEPTION_HANDLERS_KEY, func, self._cls, default_value=[]
+            )
 
     @t.no_type_check
     def middleware_config(self, middleware: "MiddlewareSchema") -> None: