Dropped control_type on module routers and EllarControllerMount. Fixed reflect to take objects and generate unique id to track them.

Author: eadwinCode

ellar/app/factory.py

@@ -14,16 +14,17 @@
     ModuleBase,
     ModuleSetup,
 )
-from ellar.core.execution_context import with_injector_context
+from ellar.core.execution_context import injector_context
 from ellar.core.module import get_core_module
 from ellar.core.modules import ModuleRefBase, ModuleTemplateRef
 from ellar.di import EllarInjector, ProviderConfig
 from ellar.di.injector.tree_manager import ModuleTreeManager
 from ellar.reflect import reflect
-from ellar.threading.sync_worker import execute_async_context_manager
+from ellar.threading.sync_worker import execute_async_context_manager, execute_coroutine
 from ellar.utils import get_name, get_unique_type
 from starlette.routing import Host, Mount
 
+from ..events.build import build_with_context_event
 from .main import App
 
 if t.TYPE_CHECKING:  # pragma: no cover
@@ -116,20 +117,24 @@ def _get_config_kwargs() -> t.Dict:
             parent_container=injector.container if injector else None,
             config=config,
         )
-        core_module_ref.initiate_module_build()
-
-        # service = EllarAppService(injector, config)
-        # service.register_core_services()
-
         with execute_async_context_manager(
-            with_injector_context(core_module_ref.container.injector)
+            injector_context(core_module_ref.container.injector)
         ) as context:
+            core_module_ref.initiate_module_build()
+
             tree_manager: ModuleTreeManager = core_module_ref.get(ModuleTreeManager)
             cls.read_all_module(core_module_ref, tree_manager)
+
+            # service = EllarAppService(injector, config)
+            # service.register_core_services()
+
             # Build application first level. This will trigger ApplicationModule to be built
             core_module_ref.build_dependencies(step=1)
             app_module_ref = tree_manager.get_app_module()
 
+            execute_coroutine(build_with_context_event.run())
+            build_with_context_event.disconnect_all()
+
             app = App(
                 routes=[],
                 config=config,

ellar/app/main.py

@@ -23,7 +23,7 @@
 from ellar.common.types import ASGIApp, TReceive, TScope, TSend
 from ellar.core import HttpRequestConnectionContext, Request
 from ellar.core.conf import Config
-from ellar.core.execution_context import with_injector_context
+from ellar.core.execution_context import injector_context
 from ellar.core.middleware import (
     Middleware as EllarMiddleware,
 )
@@ -205,7 +205,7 @@ async def __call__(self, scope: TScope, receive: TReceive, send: TSend) -> None:
         lifespan = scope["type"] == "lifespan"
         scope["app"] = self
 
-        async with with_injector_context(self.injector):
+        async with injector_context(self.injector):
             if self.middleware_stack is None:
                 self.middleware_stack = self.build_middleware_stack()
 
@@ -334,7 +334,6 @@ def url_for(context: t.Dict, name: str, **path_params: t.Any) -> URL:
         jinja_env.policies["json.dumps_function"] = json.dumps
 
         # jinja_env.policies["get_messages"] = get_messages
-
         jinja_env.globals.update(self._config.get(TEMPLATE_GLOBAL_KEY, {}))
         jinja_env.filters.update(self._config.get(TEMPLATE_FILTER_KEY, {}))
 

ellar/common/constants.py

@@ -36,6 +36,7 @@
 TEMPLATE_CONTEXT_PROCESSOR_KEY = "TEMPLATE_CONTEXT_PROCESSOR_KEY"
 TEMPLATE_FILTER_KEY = "TEMPLATE_FILTERS"
 NESTED_ROUTERS_KEY = "NESTED_ROUTERS_KEY"
+ROUTER_PRE_BUILD_ROUTES = "PRE_BUILD_ROUTES"
 
 MIDDLEWARE_HANDLERS_KEY = "MIDDLEWARE"
 APP_MIDDLEWARE_HANDLERS_KEY = "APP_MIDDLEWARE"

ellar/common/decorators/base.py

@@ -2,8 +2,7 @@
 from functools import partial
 
 from ellar.common.constants import NOT_SET
-from ellar.common.operations.router import ModuleRouter
-from ellar.reflect import ensure_target, reflect
+from ellar.reflect import reflect
 
 
 def set_metadata(
@@ -14,10 +13,6 @@ 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.get_controller_type()
-
         reflect.define_metadata(meta_key, meta_value, target)
         return target
 

ellar/common/decorators/file.py

@@ -4,7 +4,7 @@
 
 from ellar.common.constants import NOT_SET, RESPONSE_OVERRIDE_KEY
 from ellar.common.interfaces import IResponseModel
-from ellar.common.shortcuts import fail_silently
+from ellar.reflect import fail_silently
 
 from ..responses.models import FileResponseModel, StreamingResponseModel
 from .base import set_metadata as set_meta

ellar/common/decorators/html.py

@@ -13,9 +13,9 @@
 )
 from ellar.common.exceptions import ImproperConfiguration
 from ellar.common.responses.models import HTMLResponseModel
-from ellar.common.shortcuts import fail_silently
 from ellar.common.templating import TemplateFunctionData
 from ellar.common.types import TemplateFilterCallable, TemplateGlobalCallable
+from ellar.reflect import fail_silently
 from ellar.utils import class_base_function_regex, get_name
 
 from .base import set_metadata as set_meta

ellar/common/operations/router.py

@@ -1,15 +1,9 @@
 import typing as t
 
-from ellar.common.constants import (
-    GUARDS_KEY,
-    NESTED_ROUTERS_KEY,
-    VERSIONING_KEY,
-)
+from ellar.common import constants
 from ellar.common.models import GuardCanActivate
 from ellar.common.models.controller import NestedRouterInfo
-from ellar.di import injectable
 from ellar.reflect import reflect
-from ellar.utils import get_unique_type
 from starlette.middleware import Middleware
 
 from .base import OperationDefinitions
@@ -31,21 +25,17 @@ def __init__(
         include_in_schema: bool = True,
         middleware: t.Optional[t.Sequence[Middleware]] = None,
     ) -> None:
-        self._control_type: t.Type[t.Any] = injectable(get_unique_type())  # type:ignore[assignment]
+        # self._control_type: t.Type[t.Any] = injectable(get_unique_type())  # type:ignore[assignment]
         self.path = path
         self.name = name
         self.include_in_schema = include_in_schema
         self.middleware = list(middleware) if middleware else []
 
-        self._pre_build_routes: t.List[t.Union[RouteParameters, WsRouteParameters]] = []
+        reflect.define_metadata(constants.GUARDS_KEY, guards or [], self)
+        reflect.define_metadata(constants.VERSIONING_KEY, set(version or []), self)
 
-        reflect.define_metadata(GUARDS_KEY, guards or [], self.get_controller_type())
-        reflect.define_metadata(
-            VERSIONING_KEY, set(version or []), self.get_controller_type()
-        )
-
-    def get_controller_type(self) -> t.Type[t.Any]:
-        return self._control_type
+    def __repr__(self) -> str:
+        return f"<ModuleRouter path={self.path} name={self.name}>"
 
     def add_router(
         self,
@@ -54,45 +44,27 @@ def add_router(
     ) -> None:
         if prefix:
             assert prefix.startswith("/"), "'prefix' must start with '/'"
+
         reflect.define_metadata(
-            NESTED_ROUTERS_KEY,
+            constants.NESTED_ROUTERS_KEY,
             [NestedRouterInfo(prefix=prefix, router=router)],
-            self.get_controller_type(),
+            self,
         )
 
-    def get_mount_init(self) -> t.Dict[str, t.Any]:
-        return {
-            "path": self.path,
-            "name": self.name,
-            "include_in_schema": self.include_in_schema,
-            "control_type": self.get_controller_type(),
-            "middleware": self.middleware,
-        }
-
-    def get_pre_build_routes(
-        self,
-    ) -> t.List[t.Union[RouteParameters, WsRouteParameters]]:
-        return self._pre_build_routes
-
-    def clear_pre_build_routes(self) -> None:
-        self._pre_build_routes.clear()
-
     def _get_operation(self, route_parameter: RouteParameters) -> t.Callable:
         endpoint = super()._get_operation(route_parameter)
-        self._pre_build_routes.append(route_parameter)
+        reflect.define_metadata(
+            constants.ROUTER_PRE_BUILD_ROUTES, [route_parameter], self
+        )
         # self._set_other_router_attributes(ensure_function(endpoint))
+        reflect.define_metadata("ROUTER_REFLECT_KEY", self, endpoint)
         return endpoint
 
     def _get_ws_operation(self, ws_route_parameters: WsRouteParameters) -> t.Callable:
         endpoint = super()._get_ws_operation(ws_route_parameters)
-        self._pre_build_routes.append(ws_route_parameters)
+        reflect.define_metadata(
+            constants.ROUTER_PRE_BUILD_ROUTES, [ws_route_parameters], self
+        )
         # self._set_other_router_attributes(ensure_function(endpoint))
+        reflect.define_metadata("ROUTER_REFLECT_KEY", self, endpoint)
         return endpoint
-
-    # def _set_other_router_attributes(self, operation_handler: t.Callable) -> None:
-    #     if not reflect.has_metadata(CONTROLLER_CLASS_KEY, operation_handler):
-    #         # this is needed to happen before adding operation to router else we lose ability to
-    #         # get extra information about operation that is set on the router.
-    #         reflect.define_metadata(
-    #             CONTROLLER_CLASS_KEY, self.get_controller_type(), operation_handler
-    #         )

ellar/common/shortcuts.py

@@ -1,17 +1,3 @@
-from typing import Any, Callable, Optional, no_type_check
-
-from .logging import logger
-
-
-@no_type_check
-def fail_silently(func: Callable, *args: Any, **kwargs: Any) -> Optional[Any]:
-    try:
-        return func(*args, **kwargs)
-    except Exception as ex:
-        logger.debug(f"{func}, call failed. \nMessage: {ex}")
-    return None
-
-
 def normalize_path(path: str) -> str:
     while "//" in path:
         path = path.replace("//", "/")

ellar/core/__init__.py

@@ -9,7 +9,7 @@
     config,
     current_connection,
     current_injector,
-    with_injector_context,
+    injector_context,
 )
 from .guards import GuardConsumer
 from .interceptors import EllarInterceptorConsumer
@@ -50,7 +50,7 @@
     "TemplateRenderingService",
     "HttpRequestConnectionContext",
     "current_connection",
-    "with_injector_context",
+    "injector_context",
 ]
 
 

ellar/core/conf/app_settings_models.py

@@ -31,22 +31,24 @@
 
 
 _TemplateValidator = AllowTypeOfSource(
-    validator=lambda s, v: callable(v),
-    error_message=lambda v: f"Expected a callable, got {type(v)}",
+    validator=lambda source, value: callable(value),
+    error_message=lambda source, value: f"Expected a callable, got {type(value)}",
 )
 
 _VersioningValidator = AllowTypeOfSource(
-    error_message=lambda s, v: f"Expected BaseAPIVersioning, received: {type(v)}"
+    error_message=lambda source,
+    value: f"Expected BaseAPIVersioning, received: {type(value)}"
 )
 
 _MiddlewareValidator = AllowTypeOfSource(
-    validator=lambda s, v: isinstance(v, (s, Middleware)),
-    error_message=lambda s,
-    v: f"Expected EllarMiddleware or Starlette Middleware object, received: {type(v)}",
+    validator=lambda source, value: isinstance(value, (source, Middleware)),
+    error_message=lambda source,
+    value: f"Expected EllarMiddleware or Starlette Middleware object, received: {type(value)}",
 )
 
 _ExceptionHandlerValidator = AllowTypeOfSource(
-    error_message=lambda s, v: f"Expected IExceptionHandler object, received: {type(v)}"
+    error_message=lambda source,
+    value: f"Expected IExceptionHandler object, received: {type(value)}"
 )