Merge pull request #219 from python-ellar/module_builder

Module Builder Refactor

Author: eadwinCode

ellar/common/constants.py

@@ -30,7 +30,7 @@
 EXTRA_ROUTE_ARGS_KEY = "EXTRA_ROUTE_ARGS"
 RESPONSE_OVERRIDE_KEY = "RESPONSE_OVERRIDE"
 EXCEPTION_HANDLERS_KEY = "EXCEPTION_HANDLERS"
-
+MODULE_DECORATOR_ITEM = "MODULE_DECORATOR_ITEM"
 TEMPLATE_GLOBAL_KEY = "TEMPLATE_GLOBAL_FILTERS"
 TEMPLATE_FILTER_KEY = "TEMPLATE_FILTERS"
 NESTED_ROUTERS_KEY = "NESTED_ROUTERS_KEY"

ellar/common/decorators/exception.py

@@ -1,6 +1,6 @@
 import typing as t
 
-from ellar.common.constants import EXCEPTION_HANDLERS_KEY
+from ellar.common.constants import EXCEPTION_HANDLERS_KEY, MODULE_DECORATOR_ITEM
 from ellar.pydantic import BaseModel
 
 
@@ -16,6 +16,7 @@ def _add_exception_handler(
     validator = ValidateExceptionHandler(key=exc_class_or_status_code, value=handler)
     exception_handlers = {validator.key: validator.value}
     setattr(handler, EXCEPTION_HANDLERS_KEY, exception_handlers)
+    setattr(handler, MODULE_DECORATOR_ITEM, EXCEPTION_HANDLERS_KEY)
 
 
 def exception_handler(

ellar/common/decorators/html.py

@@ -4,6 +4,7 @@
 import warnings
 
 from ellar.common.constants import (
+    MODULE_DECORATOR_ITEM,
     NOT_SET,
     RESPONSE_OVERRIDE_KEY,
     TEMPLATE_FILTER_KEY,
@@ -113,6 +114,7 @@ def decorator(f: TemplateFilterCallable) -> TemplateFilterCallable:
             TEMPLATE_FILTER_KEY,
             TemplateFunctionData(func=f, name=name or get_name(f)),
         )
+        setattr(f, MODULE_DECORATOR_ITEM, TEMPLATE_FILTER_KEY)
         return f
 
     return decorator
@@ -140,6 +142,7 @@ def decorator(f: TemplateGlobalCallable) -> TemplateGlobalCallable:
             TEMPLATE_GLOBAL_KEY,
             TemplateFunctionData(func=f, name=name or get_name(f)),
         )
+        setattr(f, MODULE_DECORATOR_ITEM, TEMPLATE_GLOBAL_KEY)
         return f
 
     return decorator

ellar/common/decorators/middleware.py

@@ -1,7 +1,7 @@
 import typing as t
 
 from ellar.common.compatible import AttributeDict
-from ellar.common.constants import MIDDLEWARE_HANDLERS_KEY
+from ellar.common.constants import MIDDLEWARE_HANDLERS_KEY, MODULE_DECORATOR_ITEM
 
 
 def _add_middleware(dispatch: t.Callable, **options: t.Any) -> None:
@@ -10,6 +10,7 @@ def _add_middleware(dispatch: t.Callable, **options: t.Any) -> None:
         MIDDLEWARE_HANDLERS_KEY,
         AttributeDict(dispatch=dispatch, options=options),
     )
+    setattr(dispatch, MODULE_DECORATOR_ITEM, MIDDLEWARE_HANDLERS_KEY)
 
 
 def middleware() -> t.Callable:

ellar/core/middleware/middleware.py

@@ -12,10 +12,16 @@
 
 class EllarMiddleware(Middleware, IEllarMiddleware):
     @t.no_type_check
-    def __init__(self, cls: t.Type[T], **options: t.Any) -> None:
+    def __init__(
+        self,
+        cls: t.Type[T],
+        provider_token: t.Optional[str] = None,
+        **options: t.Any,
+    ) -> None:
         super().__init__(cls, **options)
         injectable()(self.cls)
         self.kwargs = build_init_kwargs(self.cls, self.kwargs)
+        self.provider_token = provider_token
 
     def __iter__(self) -> t.Iterator[t.Any]:
         as_tuple = (self, self.args, self.kwargs)

ellar/core/modules/base.py

@@ -12,16 +12,19 @@
 
 
 class ModuleBaseMeta(type):
-    __MODULE_FIELDS__: t.Dict = {}
+    MODULE_FIELDS: t.Dict = {}
+
+    def build_module_actions(cls) -> None:
+        ModuleBaseBuilder(cls).build()
 
     @t.no_type_check
     def __init__(cls, name, bases, namespace) -> None:
         super().__init__(name, bases, namespace)
-        cls.__MODULE_FIELDS__: t.Dict = {}
+        setattr(cls, MODULE_FIELDS, {})
 
-        for base in reversed(bases):
-            ModuleBaseBuilder(cls).build(getattr(base, MODULE_FIELDS, base.__dict__))
-        ModuleBaseBuilder(cls).build(namespace)
+        # for base in reversed(bases):
+        #     ModuleBaseBuilder(cls).build(getattr(base, MODULE_FIELDS, base.__dict__))
+        # ModuleBaseBuilder(cls).build(namespace)
 
 
 class ModuleBase(_InjectorModule, metaclass=ModuleBaseMeta):

ellar/core/modules/builder.py

@@ -4,14 +4,16 @@
 from ellar.common.constants import (
     EXCEPTION_HANDLERS_KEY,
     MIDDLEWARE_HANDLERS_KEY,
-    MODULE_FIELDS,
+    MODULE_DECORATOR_ITEM,
+    MODULE_METADATA,
     TEMPLATE_FILTER_KEY,
     TEMPLATE_GLOBAL_KEY,
 )
 from ellar.common.exceptions import CallableExceptionHandler
 from ellar.core.middleware import FunctionBasedMiddleware, Middleware
 from ellar.reflect import reflect
 
+from ...utils import get_functions_with_tag
 from .helper import module_callable_factory
 
 if t.TYPE_CHECKING:  # pragma: no cover
@@ -24,9 +26,6 @@ class ModuleBaseBuilder:
 
     def __init__(self, cls: t.Union[t.Type["ModuleBase"], "ModuleBaseMeta"]) -> None:
         self._cls = cls
-        self._cls.__MODULE_FIELDS__ = t.cast(
-            t.Dict, getattr(self._cls, MODULE_FIELDS, None) or {}
-        )
         self._actions: t.Dict[str, t.Callable[[t.Any], None]] = {}
         self._actions.update(
             {
@@ -39,50 +38,47 @@ 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 = CallableExceptionHandler(
-                self._cls, callable_exception_handler=v, exc_class_or_status_code=k
+            self._cls.MODULE_FIELDS.setdefault(EXCEPTION_HANDLERS_KEY, []).append(
+                CallableExceptionHandler(
+                    callable_exception_handler=module_callable_factory(v, self._cls),
+                    exc_class_or_status_code=k,
+                )
             )
-            reflect.define_metadata(EXCEPTION_HANDLERS_KEY, [func], self._cls)
 
     @t.no_type_check
     def middleware_config(self, middleware: AttributeDict) -> None:
         dispatch = module_callable_factory(middleware.dispatch, self._cls)
-        reflect.define_metadata(
-            MIDDLEWARE_HANDLERS_KEY,
-            [
-                Middleware(
-                    FunctionBasedMiddleware, dispatch=dispatch, **middleware.options
-                )
-            ],
-            self._cls,
+        self._cls.MODULE_FIELDS.setdefault(MIDDLEWARE_HANDLERS_KEY, []).append(
+            Middleware(
+                FunctionBasedMiddleware,
+                dispatch=dispatch,
+                **middleware.options,
+                provider_token=reflect.get_metadata(MODULE_METADATA.NAME, self._cls),
+            )
         )
 
     def template_filter_config(self, template_filter: "TemplateFunctionData") -> None:
-        reflect.define_metadata(
-            TEMPLATE_FILTER_KEY,
+        self._cls.MODULE_FIELDS.setdefault(TEMPLATE_FILTER_KEY, {}).update(
             {
                 template_filter.name: module_callable_factory(
                     template_filter.func, self._cls
                 )
-            },
-            self._cls,
+            }
         )
 
     def template_global_config(self, template_filter: "TemplateFunctionData") -> None:
-        reflect.define_metadata(
-            TEMPLATE_GLOBAL_KEY,
+        self._cls.MODULE_FIELDS.setdefault(TEMPLATE_GLOBAL_KEY, {}).update(
             {
                 template_filter.name: module_callable_factory(
                     template_filter.func, self._cls
                 )
-            },
-            self._cls,
+            }
         )
 
-    def build(self, namespace: t.Dict) -> None:
-        for name, item in namespace.items():
-            for k, func in self._actions.items():
-                if hasattr(item, k):
-                    value = item.__dict__.pop(k)
-                    func(value)
-                    self._cls.__MODULE_FIELDS__[name] = item
+    def build(self) -> None:
+        self._cls.MODULE_FIELDS = {}
+
+        for _, item in get_functions_with_tag(self._cls, MODULE_DECORATOR_ITEM):
+            action_name = getattr(item, MODULE_DECORATOR_ITEM)
+            handler = self._actions[action_name]
+            handler(item.__dict__[action_name])

ellar/core/modules/ref.py

@@ -178,8 +178,11 @@ def __init__(
         # self._flatten_routes: t.List[BaseRoute] = []
 
         if isinstance(self.module, type) and issubclass(self.module, ModuleBase):
+            self.module.build_module_actions()
+
             self.scan_templating_filters()
             self.scan_exceptions_handlers()
+
             self.scan_middleware()
 
         self.register_providers()
@@ -224,39 +227,22 @@ def _register_module(self) -> None:
         )
 
     def scan_templating_filters(self) -> None:
-        templating_filter = (
-            reflect.get_metadata(TEMPLATE_FILTER_KEY, self._module_type) or {}
-        )
-        if not self._config.get(TEMPLATE_FILTER_KEY) or not isinstance(
-            self._config[TEMPLATE_FILTER_KEY], dict
-        ):
-            self._config[TEMPLATE_FILTER_KEY] = {}
-        self._config[TEMPLATE_FILTER_KEY].update(templating_filter)
-
-        templating_global_filter = (
-            reflect.get_metadata(TEMPLATE_GLOBAL_KEY, self._module_type) or {}
+        templating_filter = self.module.MODULE_FIELDS.get(TEMPLATE_FILTER_KEY, {})
+        self.config.setdefault(TEMPLATE_FILTER_KEY, {}).update(templating_filter)
+
+        templating_global_filter = self.module.MODULE_FIELDS.get(
+            TEMPLATE_GLOBAL_KEY, {}
         )
-        if not self._config.get(TEMPLATE_GLOBAL_KEY) or not isinstance(
-            self._config[TEMPLATE_GLOBAL_KEY], dict
-        ):
-            self._config[TEMPLATE_GLOBAL_KEY] = {}
-        self._config[TEMPLATE_GLOBAL_KEY].update(templating_global_filter)
+        self.config.setdefault(TEMPLATE_GLOBAL_KEY, {}).update(templating_global_filter)
 
     def scan_exceptions_handlers(self) -> None:
-        exception_handlers = (
-            reflect.get_metadata(EXCEPTION_HANDLERS_KEY, self._module_type) or []
-        )
-        self._config[EXCEPTION_HANDLERS_KEY].extend(exception_handlers)
+        exception_handlers = self.module.MODULE_FIELDS.get(EXCEPTION_HANDLERS_KEY, [])
+
+        self.config.setdefault(EXCEPTION_HANDLERS_KEY, []).extend(exception_handlers)
 
     def scan_middleware(self) -> None:
-        middleware = (
-            reflect.get_metadata(MIDDLEWARE_HANDLERS_KEY, self._module_type) or []
-        )
-        if not self._config.get(MIDDLEWARE_HANDLERS_KEY) or not isinstance(
-            self._config[MIDDLEWARE_HANDLERS_KEY], list
-        ):
-            self._config[MIDDLEWARE_HANDLERS_KEY] = []
-        self._config[MIDDLEWARE_HANDLERS_KEY].extend(middleware)
+        middleware = self.module.MODULE_FIELDS.get(MIDDLEWARE_HANDLERS_KEY, [])
+        self.config.setdefault(MIDDLEWARE_HANDLERS_KEY, []).extend(middleware)
 
     def register_providers(self) -> None:
         providers = (

ellar/core/router_builders/controller.py

@@ -4,6 +4,7 @@
     CONTROLLER_METADATA,
     CONTROLLER_OPERATION_HANDLER_KEY,
     CONTROLLER_WATERMARK,
+    OPERATION_ENDPOINT_KEY,
     ROUTE_OPERATION_PARAMETERS,
 )
 from ellar.common.logging import logger
@@ -18,8 +19,9 @@
 from ellar.reflect import reflect
 from starlette.routing import BaseRoute
 
+from ...utils import get_functions_with_tag
 from .base import RouterBuilder
-from .utils import get_route_functions, process_nested_routes
+from .utils import process_nested_routes
 
 T_ = t.TypeVar("T_")
 
@@ -30,7 +32,7 @@ def process_controller_routes(controller: t.Type[ControllerBase]) -> t.List[Base
     if reflect.get_metadata(CONTROLLER_METADATA.PROCESSED, controller):
         return reflect.get_metadata(CONTROLLER_OPERATION_HANDLER_KEY, controller) or []
 
-    for _, item in get_route_functions(controller):
+    for _, item in get_functions_with_tag(controller, tag=OPERATION_ENDPOINT_KEY):
         parameters = item.__dict__[ROUTE_OPERATION_PARAMETERS]
         operation: t.Union[ControllerRouteOperation, ControllerWebsocketRouteOperation]
 

ellar/core/router_builders/utils.py

@@ -1,4 +1,3 @@
-import inspect
 import typing as t
 from types import FunctionType
 
@@ -7,7 +6,6 @@
     CONTROLLER_METADATA,
     CONTROLLER_OPERATION_HANDLER_KEY,
     NESTED_ROUTERS_KEY,
-    OPERATION_ENDPOINT_KEY,
     ROUTE_OPERATION_PARAMETERS,
 )
 from ellar.common.exceptions import ImproperConfiguration
@@ -30,14 +28,6 @@
 _stack_cycle: t.Tuple = ()
 
 
-def get_route_functions(
-    klass: t.Type, key: str = OPERATION_ENDPOINT_KEY
-) -> t.Iterable[t.Tuple[str, t.Callable]]:
-    for method_name, method in inspect.getmembers(klass, predicate=inspect.isfunction):
-        if hasattr(method, key):
-            yield method_name, method
-
-
 def process_nested_routes(controller: t.Type[t.Any]) -> t.List[BaseRoute]:
     global _stack_cycle