some minor updates and bug fixes on package

Author: eadwinCode

ellar/common/compatible/dict.py

@@ -6,7 +6,7 @@
 class AttributeDictAccessMixin:
     def __getattribute__(self, name: t.Any) -> t.Optional[t.Any]:
         if name in self:
-            return self[name]
+            return self.__attribute_dict__(self[name])
         try:
             return super(AttributeDictAccessMixin, self).__getattribute__(name)
         except Exception:
@@ -17,6 +17,9 @@ def __missing__(self, name) -> VT:
             f"'{self.__class__.__name__}' object has no attribute '{name}'"
         )
 
+    def __attribute_dict__(self, value: t.Any) -> t.Any:
+        return value
+
 
 class AttributeDict(AttributeDictAccessMixin, t.Dict[KT, VT]):
     def __setattr__(self, name: KT, value: VT) -> None:  # type: ignore
@@ -28,3 +31,8 @@ def set_defaults(self, **kwargs: t.Any) -> None:
 
     def __missing__(self, name) -> VT:
         return None
+
+    def __attribute_dict__(self, value: t.Any) -> t.Any:
+        if isinstance(value, dict):
+            return self.__class__(value)
+        return value

ellar/common/constants.py

@@ -30,15 +30,17 @@
 EXTRA_ROUTE_ARGS_KEY = "EXTRA_ROUTE_ARGS"
 RESPONSE_OVERRIDE_KEY = "RESPONSE_OVERRIDE"
 EXCEPTION_HANDLERS_KEY = "EXCEPTION_HANDLERS"
+APP_EXCEPTION_HANDLERS_KEY = "APP_EXCEPTION_HANDLERS"
 MODULE_DECORATOR_ITEM = "MODULE_DECORATOR_ITEM"
 TEMPLATE_GLOBAL_KEY = "TEMPLATE_GLOBAL_FILTERS"
+TEMPLATE_CONTEXT_PROCESSOR_KEY = "TEMPLATE_CONTEXT_PROCESSOR_KEY"
 TEMPLATE_FILTER_KEY = "TEMPLATE_FILTERS"
 NESTED_ROUTERS_KEY = "NESTED_ROUTERS_KEY"
 
 MIDDLEWARE_HANDLERS_KEY = "MIDDLEWARE"
+APP_MIDDLEWARE_HANDLERS_KEY = "APP_MIDDLEWARE"
 
 MODULE_WATERMARK = "MODULE_WATERMARK"
-MODULE_FIELDS = "__MODULE_FIELDS__"
 CONTROLLER_WATERMARK = "CONTROLLER_WATERMARK"
 
 MULTI_RESOLVER_KEY = "MULTI_RESOLVER_KEY"
@@ -54,6 +56,7 @@
 
 GROUP_METADATA = "GROUP_METADATA"
 SKIP_AUTH = "SKIP_AUTH"
+MODULE_COMPONENT = "MODULE_COMPONENT"
 
 
 class MODULE_METADATA(metaclass=AnnotationToValue):

ellar/common/decorators/base.py

@@ -3,7 +3,7 @@
 
 from ellar.common.constants import NOT_SET
 from ellar.common.operations.router import ModuleRouter
-from ellar.reflect import reflect
+from ellar.reflect import ensure_target, reflect
 
 
 def set_metadata(
@@ -14,8 +14,9 @@ def set_metadata(
         return partial(set_metadata, meta_key)
 
     def _decorator(target: t.Union[t.Callable, t.Any]) -> t.Callable:
+        target = ensure_target(target)
         if isinstance(target, ModuleRouter):
-            target = target.control_type
+            target = target.get_controller_type()
 
         reflect.define_metadata(meta_key, meta_value, target)
         return target

ellar/common/decorators/controller.py

@@ -9,7 +9,7 @@
 from ellar.common.exceptions import ImproperConfiguration
 from ellar.common.models import ControllerBase, ControllerType
 from ellar.di import RequestORTransientScope, injectable
-from ellar.reflect import REFLECT_TYPE, reflect
+from ellar.reflect import reflect, transfer_metadata
 from injector import Scope
 from starlette.middleware import Middleware
 
@@ -64,10 +64,9 @@ def _decorator(cls: t.Type) -> t.Type[ControllerBase]:
         if type(cls) is not ControllerType:
             # We force the cls to inherit from `ControllerBase` by creating another type.
             attrs = {}
-            if hasattr(cls, REFLECT_TYPE):
-                attrs.update({REFLECT_TYPE: cls.__dict__[REFLECT_TYPE]})
             new_cls = type(cls.__name__, (cls, ControllerBase), attrs)
 
+            transfer_metadata(cls, new_cls)
             _controller_type = t.cast(t.Type[ControllerBase], new_cls)
 
         _tag = _controller_type.controller_class_name()
@@ -82,19 +81,6 @@ def _decorator(cls: t.Type) -> t.Type[ControllerBase]:
                 .replace("controller", "")
             )
 
-        # for base in get_type_of_base(ControllerBase, _controller_type):
-        #     if reflect.has_metadata(CONTROLLER_WATERMARK, base) and hasattr(
-        #         cls, "__CONTROLLER_WATERMARK__"
-        #     ):
-        #         raise ImproperConfiguration(
-        #             f"`@Controller` decorated classes does not support inheritance. \n"
-        #             f"{_controller_type}"
-        #         )
-
-        # if not reflect.has_metadata(
-        #     CONTROLLER_WATERMARK, _controller_type
-        # ) and not hasattr(cls, "__CONTROLLER_WATERMARK__"):
-
         reflect.define_metadata(CONTROLLER_WATERMARK, True, _controller_type)
         # reflect_all_controller_type_routes(_controller_type)
 

ellar/common/decorators/exception.py

@@ -12,26 +12,28 @@ class ValidateExceptionHandler(BaseModel):
 def _add_exception_handler(
     exc_class_or_status_code: t.Union[int, t.Type[Exception]],
     handler: t.Union[t.Callable, t.Type],
+    app: bool = False,
 ) -> None:
     validator = ValidateExceptionHandler(key=exc_class_or_status_code, value=handler)
-    exception_handlers = {validator.key: validator.value}
+    exception_handlers = {validator.key: (validator.value, app)}
     setattr(handler, EXCEPTION_HANDLERS_KEY, exception_handlers)
     setattr(handler, MODULE_DECORATOR_ITEM, EXCEPTION_HANDLERS_KEY)
 
 
 def exception_handler(
-    exc_class_or_status_code: t.Union[int, t.Type[Exception]],
+    exc_or_status_code: t.Union[int, t.Type[Exception]], app: bool = False
 ) -> t.Callable:
     """
     ========= MODULE DECORATOR ==============
 
     Defines Exception Handler at Module Level
-    :param exc_class_or_status_code:
+    :param exc_or_status_code: Exception Class or Status Code
+    :param app: Indicates Exception Handler will be global to the application
     :return: Function
     """
 
     def decorator(func: t.Union[t.Callable, t.Type]) -> t.Callable:
-        _add_exception_handler(exc_class_or_status_code, func)
+        _add_exception_handler(exc_or_status_code, func, app)
         return func
 
     return decorator

ellar/common/decorators/middleware.py

@@ -4,16 +4,16 @@
 from ellar.common.constants import MIDDLEWARE_HANDLERS_KEY, MODULE_DECORATOR_ITEM
 
 
-def _add_middleware(dispatch: t.Callable, **options: t.Any) -> None:
+def _add_middleware(dispatch: t.Callable, app: bool = False, **options: t.Any) -> None:
     setattr(
         dispatch,
         MIDDLEWARE_HANDLERS_KEY,
-        AttributeDict(dispatch=dispatch, options=options),
+        AttributeDict(dispatch=dispatch, options=options, is_global=app),
     )
     setattr(dispatch, MODULE_DECORATOR_ITEM, MIDDLEWARE_HANDLERS_KEY)
 
 
-def middleware() -> t.Callable:
+def middleware(app: bool = False) -> t.Callable:
     """
     ========= MODULE DECORATOR ==============
 
@@ -32,7 +32,7 @@ async def my_middleware(cls, context: IExecutionContext, call_next):
     """
 
     def decorator(func: t.Callable) -> t.Callable:
-        _add_middleware(dispatch=func)
+        _add_middleware(dispatch=func, app=app)
         return func
 
     return decorator

ellar/common/decorators/modules.py

@@ -31,15 +31,20 @@ def _wrapper(
     if not isinstance(target, type):
         raise ImproperConfiguration(f"{name} is a class decorator - {target}")
 
-    if not kwargs.base_directory:
+    if not kwargs.base_directory and not reflect.get_metadata(
+        MODULE_METADATA.BASE_DIRECTORY, target
+    ):
         kwargs.update(base_directory=Path(inspect.getfile(target)).resolve().parent)
 
-    if not kwargs.name:
+    if not kwargs.name and not reflect.get_metadata(MODULE_METADATA.NAME, target):
         kwargs.name = f"{get_name(target)}{uuid.uuid4().hex[:10]}"
 
     reflect.define_metadata(watermark_key, True, target)
+
     for key in metadata_keys:
-        reflect.define_metadata(key, kwargs[key], target)
+        if not reflect.get_metadata(key, target) or kwargs[key] is not None:
+            reflect.define_metadata(key, kwargs[key], target)
+
     injectable(SingletonScope)(target)
     return target
 

ellar/common/exceptions/callable_exceptions.py

@@ -40,25 +40,25 @@ def exception_handler_fun(ctx: IExecutionContext, exc: Exception):
     def __init__(
         self,
         *func_args: t.Any,
-        exc_class_or_status_code: t.Union[t.Type[Exception], int],
-        callable_exception_handler: t.Union[
+        exc_or_status_code: t.Union[t.Type[Exception], int],
+        handler: t.Union[
             t.Callable[
                 [IHostContext, Exception],
                 t.Union[t.Awaitable[Response], Response, t.Any],
             ],
             t.Any,
         ],
     ) -> None:
-        self.callable_exception_handler = callable_exception_handler
+        self.callable_exception_handler = handler
         self.is_async = False
         self.func_args = func_args
 
-        if not isinstance(exc_class_or_status_code, int):
-            assert issubclass(exc_class_or_status_code, Exception)
+        if not isinstance(exc_or_status_code, int):
+            assert issubclass(exc_or_status_code, Exception)
 
-        self.exception_type_or_code = exc_class_or_status_code
+        self.exception_type_or_code = exc_or_status_code
 
-        if is_async_callable(callable_exception_handler):
+        if is_async_callable(handler):
             self.is_async = True
 
     async def catch(

ellar/common/interfaces/__init__.py

@@ -16,7 +16,7 @@
 from .middleware import IEllarMiddleware
 from .module import IModuleSetup
 from .response_model import IResponseModel
-from .templating import IModuleTemplateLoader
+from .templating import IModuleTemplateLoader, ITemplateRenderingService
 from .versioning import IAPIVersioning, IAPIVersioningResolver
 
 __all__ = [
@@ -42,4 +42,5 @@
     "IEllarMiddleware",
     "IIdentitySchemes",
     "IApplicationReady",
+    "ITemplateRenderingService",
 ]

ellar/common/interfaces/exceptions.py

@@ -1,20 +1,12 @@
 import typing as t
 from abc import ABC, abstractmethod
 
-from ellar.pydantic import as_pydantic_validator
 from starlette.responses import Response
 
 from .context import IHostContext
 
 
-@as_pydantic_validator("__validate_input__", schema={"type": "object"})
 class IExceptionHandler(ABC, t.Iterable):
-    @classmethod
-    def __validate_input__(cls, v: t.Any, _: t.Any) -> t.Any:
-        if not isinstance(v, cls):
-            raise ValueError(f"Expected IExceptionHandler object, received: {type(v)}")
-        return v
-
     def __eq__(self, other: t.Any) -> bool:
         if isinstance(other, IExceptionHandler):
             return other.exception_type_or_code == self.exception_type_or_code
@@ -42,7 +34,9 @@ def __init_subclass__(cls, **kwargs: t.Any) -> None:
 
 class IExceptionMiddlewareService:
     @abstractmethod
-    def build_exception_handlers(self, *exception_handlers: IExceptionHandler) -> None:
+    def build_exception_handlers(
+        self, *exception_handlers: IExceptionHandler
+    ) -> "IExceptionMiddlewareService":
         """Build Exception Handlers"""
 
     @abstractmethod