Enable operation outside modulerouter to be computation

Author: eadwinCode

ellar/core/connection/__init__.py ellar/core/connection.pyellar/core/connection/__init__.py renamed to ellar/core/connection.py

@@ -4,9 +4,8 @@
     RequestParameter,
     WebSocketParameter,
 )
-
-from .http import HTTPConnection, Request
-from .websocket import WebSocket
+from starlette.requests import HTTPConnection, Request
+from starlette.websockets import WebSocket
 
 __all__ = ["HTTPConnection", "Request", "WebSocket"]
 

ellar/core/router_builders/base.py

@@ -1,9 +1,10 @@
+import inspect
 import typing as t
 from abc import abstractmethod
 
-from ellar.common.logging import logger
-from ellar.core.routing.mount import EllarMount
-from starlette.routing import Host, Mount
+from ellar.common.constants import NOT_SET
+from ellar.core.routing.mount import EllarControllerMount
+from starlette.routing import BaseRoute, Host, Mount
 
 _router_builder_factory: t.Dict[t.Type, t.Type["RouterBuilder"]] = {}
 
@@ -15,28 +16,24 @@ def _register_controller_builder(
 
 
 def get_controller_builder_factory(
-    controller_type: t.Type,
+    controller_type: t.Union[t.Type, t.Any] = NOT_SET,
 ) -> t.Type["RouterBuilder"]:
     res = _router_builder_factory.get(controller_type)
     if not res:
-        logger.warning(
-            f"Router Factory Builder was not found.\nUse `ControllerRouterBuilderFactory` "
-            f"as an example create a FactoryBuilder for this type: {controller_type}"
-        )
         return _DefaultRouterBuilder
     return res
 
 
 class RouterBuilder:
     """
-    A factory class that validates and converts a Controllers or ModuleRouter to Starlette Mount or EllarMount.
+    A factory class that validates and converts a Controllers or ModuleRouter to Starlette Mount or EllarControllerMount.
     """
 
     @classmethod
     @abstractmethod
     def build(
         cls, controller_type: t.Union[t.Type, t.Any], **kwargs: t.Any
-    ) -> t.Union["EllarMount", Mount]:
+    ) -> t.Union["EllarControllerMount", Mount]:
         """Build controller to Mount"""
 
     @classmethod
@@ -58,10 +55,21 @@ def check_type(cls, controller_type: t.Union[t.Type, t.Any]) -> None:
     @classmethod
     def build(
         cls, controller_type: t.Union[t.Type, t.Any], **kwargs: t.Any
-    ) -> t.Union["EllarMount", Mount, t.Any]:
+    ) -> t.Union["EllarControllerMount", Mount, t.Any]:
         """Build controller to Mount"""
+        from ellar.core.router_builders.utils import build_route_handler
+
+        if inspect.isfunction(controller_type):
+            operations: t.Any = build_route_handler(controller_type)
+
+            for op in operations or []:
+                if not isinstance(op, BaseRoute):
+                    raise Exception(f"Unable to build function - {controller_type}")
+            return operations
+
         return controller_type
 
 
 _register_controller_builder(Host, _DefaultRouterBuilder)
-_register_controller_builder(EllarMount, _DefaultRouterBuilder)
+_register_controller_builder(EllarControllerMount, _DefaultRouterBuilder)
+_register_controller_builder(NOT_SET, _DefaultRouterBuilder)

ellar/core/router_builders/controller.py

@@ -14,7 +14,7 @@
 from ellar.core.routing import (
     ControllerRouteOperation,
     ControllerWebsocketRouteOperation,
-    EllarMount,
+    EllarControllerMount,
 )
 from ellar.reflect import reflect
 from starlette.routing import BaseRoute
@@ -41,10 +41,12 @@ def process_controller_routes(controller: t.Type[ControllerBase]) -> t.List[Base
 
         for parameter in parameters:
             if isinstance(parameter, RouteParameters):
-                operation = ControllerRouteOperation(controller, **parameter.dict())
+                operation = ControllerRouteOperation(
+                    **parameter.dict(), controller_class=controller
+                )
             elif isinstance(parameter, WsRouteParameters):
                 operation = ControllerWebsocketRouteOperation(
-                    controller, **parameter.dict()
+                    **parameter.dict(), controller_class=controller
                 )
             else:  # pragma: no cover
                 logger.warning(
@@ -66,9 +68,11 @@ class ControllerRouterBuilder(RouterBuilder, controller_type=type(ControllerBase
     def build(
         cls,
         controller_type: t.Union[t.Type[ControllerBase], t.Any],
-        base_route_type: t.Type[t.Union[EllarMount, T_]] = EllarMount,
+        base_route_type: t.Type[
+            t.Union[EllarControllerMount, T_]
+        ] = EllarControllerMount,
         **kwargs: t.Any,
-    ) -> t.Union[T_, EllarMount]:
+    ) -> t.Union[T_, EllarControllerMount]:
         routes = process_controller_routes(controller_type)
         routes.extend(process_nested_routes(controller_type))
 
@@ -80,7 +84,7 @@ def build(
             CONTROLLER_METADATA.MIDDLEWARE, controller_type
         )
 
-        kwargs.setdefault("middleware", middleware)
+        kwargs.update(middleware=middleware)
 
         path = reflect.get_metadata_or_raise_exception(
             CONTROLLER_METADATA.PATH, controller_type

ellar/core/router_builders/module_router.py

@@ -4,7 +4,7 @@
 from ellar.common.compatible import AttributeDict
 from ellar.common.constants import CONTROLLER_METADATA, CONTROLLER_OPERATION_HANDLER_KEY
 from ellar.common.shortcuts import normalize_path
-from ellar.core.routing import EllarMount
+from ellar.core.routing import EllarControllerMount
 from ellar.reflect import reflect
 
 from .base import RouterBuilder
@@ -18,20 +18,23 @@ class ModuleRouterBuilder(RouterBuilder, controller_type=ModuleRouter):
     def build(
         cls,
         controller_type: t.Union[ModuleRouter, t.Any],
-        base_route_type: t.Type[t.Union[EllarMount, T_]] = EllarMount,
+        base_route_type: t.Type[
+            t.Union[EllarControllerMount, T_]
+        ] = EllarControllerMount,
         **kwargs: t.Any,
-    ) -> t.Union[T_, EllarMount]:
+    ) -> t.Union[T_, EllarControllerMount]:
         if reflect.get_metadata(
-            CONTROLLER_METADATA.PROCESSED, controller_type.control_type
+            CONTROLLER_METADATA.PROCESSED, controller_type.get_controller_type()
         ):
             routes = reflect.get_metadata(
-                CONTROLLER_OPERATION_HANDLER_KEY, controller_type.control_type
+                CONTROLLER_OPERATION_HANDLER_KEY, controller_type.get_controller_type()
             )
         else:
             routes = build_route_parameters(
-                controller_type.get_pre_build_routes(), controller_type.control_type
+                controller_type.get_pre_build_routes(),
+                controller_class=controller_type.get_controller_type(),
             )
-            routes.extend(process_nested_routes(controller_type.control_type))
+            routes.extend(process_nested_routes(controller_type.get_controller_type()))
 
         init_kwargs = AttributeDict(controller_type.get_mount_init())
 
@@ -43,7 +46,7 @@ def build(
         router = base_route_type(**init_kwargs, routes=routes)  # type:ignore[call-arg]
 
         reflect.define_metadata(
-            CONTROLLER_METADATA.PROCESSED, True, controller_type.control_type
+            CONTROLLER_METADATA.PROCESSED, True, controller_type.get_controller_type()
         )
         return router
 

ellar/core/router_builders/utils.py

@@ -2,10 +2,10 @@
 from types import FunctionType
 
 from ellar.common.constants import (
-    CONTROLLER_CLASS_KEY,
     CONTROLLER_METADATA,
     CONTROLLER_OPERATION_HANDLER_KEY,
     NESTED_ROUTERS_KEY,
+    NOT_SET,
     ROUTE_OPERATION_PARAMETERS,
 )
 from ellar.common.exceptions import ImproperConfiguration
@@ -18,7 +18,6 @@
     WebsocketRouteOperation,
 )
 from ellar.reflect import reflect
-from ellar.utils import get_unique_type
 from starlette.routing import BaseRoute
 
 from .base import get_controller_builder_factory
@@ -72,19 +71,16 @@ def build_route_handler(
 ) -> t.Optional[t.List[RouteOperationBase]]:
     _item: t.Any = item
 
-    if callable(item) and type(item) == FunctionType:
+    if callable(item) and type(item) is FunctionType:
         _item = reflect.get_metadata(CONTROLLER_OPERATION_HANDLER_KEY, item)
 
-    if not _item and not reflect.has_metadata(CONTROLLER_CLASS_KEY, item):
-        reflect.define_metadata(CONTROLLER_CLASS_KEY, get_unique_type(), item)
-
     if not _item and hasattr(item, ROUTE_OPERATION_PARAMETERS):
         parameters = item.__dict__[ROUTE_OPERATION_PARAMETERS]
 
         if not isinstance(parameters, list):
             parameters = [parameters]
 
-        operations = build_route_parameters(parameters, get_unique_type())
+        operations = build_route_parameters(parameters)
         if isinstance(operations, list):
             return operations
 
@@ -96,15 +92,14 @@ def build_route_handler(
 
 @t.no_type_check
 def build_route_parameters(
-    items: t.List[t.Union[RouteParameters, WsRouteParameters]],
-    control_type: t.Type[t.Any],
+    items: t.List[t.Union[RouteParameters, WsRouteParameters]], **kwargs: t.Any
 ) -> t.List[t.Union[RouteOperationBase, t.Any]]:
     results = []
     for item in items:
         if isinstance(item, RouteParameters):
-            operation = RouteOperation(**item.dict())
+            operation = RouteOperation(**item.dict(), **kwargs)
         elif isinstance(item, WsRouteParameters):
-            operation = WebsocketRouteOperation(**item.dict())
+            operation = WebsocketRouteOperation(**item.dict(), **kwargs)
         else:  # pragma: no cover
             logger.warning(
                 f"Parameter type is not recognized. {type(item) if not isinstance(item, type) else item}"
@@ -115,10 +110,11 @@ def build_route_parameters(
         if ROUTE_OPERATION_PARAMETERS in item.endpoint.__dict__:
             del item.endpoint.__dict__[ROUTE_OPERATION_PARAMETERS]
 
-        reflect.define_metadata(
-            CONTROLLER_OPERATION_HANDLER_KEY,
-            [operation],
-            control_type,
-        )
+        if operation.get_controller_type() is not NOT_SET:
+            reflect.define_metadata(
+                CONTROLLER_OPERATION_HANDLER_KEY,
+                [operation],
+                operation.get_controller_type(),
+            )
 
     return results

ellar/core/routing/__init__.py

@@ -10,7 +10,7 @@
     ControllerWebsocketRouteOperation,
 )
 from .file_mount import AppStaticFileMount, ASGIFileMount
-from .mount import ApplicationRouter, EllarMount
+from .mount import ApplicationRouter, EllarControllerMount
 from .route import RouteOperation
 from .route_collections import RouteCollection
 from .websocket import WebsocketRouteOperation
@@ -19,7 +19,7 @@
     "Param",
     "ParamTypes",
     "RouteCollection",
-    "EllarMount",
+    "EllarControllerMount",
     "RouteOperation",
     "RouteOperationBase",
     "WebsocketRouteOperation",

ellar/core/routing/base.py

@@ -1,9 +1,8 @@
 import typing as t
 from abc import ABC, abstractmethod
-from contextlib import asynccontextmanager
 
 from ellar.common.constants import (
-    CONTROLLER_CLASS_KEY,
+    NOT_SET,
     SCOPE_API_VERSIONING_RESOLVER,
     VERSIONING_KEY,
 )
@@ -15,7 +14,8 @@
 )
 from ellar.common.logging import request_logger
 from ellar.common.types import TReceive, TScope, TSend
-from ellar.core.context import current_injector
+from ellar.core.execution_context import current_injector
+from ellar.di import register_request_scope_context
 from ellar.reflect import reflect
 from starlette.routing import Match
 
@@ -33,13 +33,11 @@ class RouteOperationBase:
     methods: t.Set[str]
     _controller_type: t.Optional[t.Union[t.Type, t.Type["ControllerBase"]]] = None
 
-    def __init__(self, endpoint: t.Callable) -> None:
+    def __init__(
+        self, endpoint: t.Callable, controller_class: t.Optional[t.Type] = None
+    ) -> None:
         self.endpoint = endpoint
-        _controller_type: t.Type = self.get_controller_type()
-
-        self._controller_type: t.Union[t.Type, t.Type["ControllerBase"]] = t.cast(
-            t.Union[t.Type, t.Type["ControllerBase"]], _controller_type
-        )
+        self._controller_type = controller_class or NOT_SET
 
     # @t.no_type_check
     # def __call__(
@@ -51,23 +49,6 @@ def __init__(self, endpoint: t.Callable) -> None:
     def _load_model(self) -> None:
         """compute route models"""
 
-    @asynccontextmanager
-    async def _ensure_dependency_availability(
-        self, context: IExecutionContext
-    ) -> t.AsyncGenerator:
-        controller_type = context.get_class()
-        module_scope_owner = next(
-            context.get_app().injector.tree_manager.find_module(
-                lambda data: controller_type in data.providers
-                or controller_type in data.exports
-            )
-        )
-        if module_scope_owner and module_scope_owner.is_ready:
-            async with module_scope_owner.value.context():
-                yield
-        else:
-            yield
-
     async def app(self, scope: TScope, receive: TReceive, send: TSend) -> None:
         request_logger.debug(
             f"Started Computing Execution Context - '{self.__class__.__name__}'"
@@ -77,19 +58,19 @@ async def app(self, scope: TScope, receive: TReceive, send: TSend) -> None:
         context = execution_context_factory.create_context(
             operation=self, scope=scope, receive=receive, send=send
         )
-        current_injector.update_scoped_context(IExecutionContext, context)
+        register_request_scope_context(IExecutionContext, context)
 
         interceptor_consumer = current_injector.get(IInterceptorsConsumer)
         guard_consumer = current_injector.get(IGuardsConsumer)
 
         request_logger.debug(
             f"Running Guards and Interceptors - '{self.__class__.__name__}'"
         )
-        async with self._ensure_dependency_availability(context):
-            await guard_consumer.execute(context, self)
-            await interceptor_consumer.execute(context, self)
 
-    def get_controller_type(self) -> t.Type:
+        await guard_consumer.execute(context, self)
+        await interceptor_consumer.execute(context, self)
+
+    def get_controller_type(self) -> t.Any:
         """
         For operation under a controller, `get_control_type` and `get_class` will return the same result
         For operation under ModuleRouter, this will return a unique type created for the router for tracking some properties
@@ -98,11 +79,6 @@ def get_controller_type(self) -> t.Type:
         request_logger.debug(
             f"Resolving Endpoint Handler Controller Type - '{self.__class__.__name__}'"
         )
-        if not self._controller_type:
-            _controller_type = reflect.get_metadata(CONTROLLER_CLASS_KEY, self.endpoint)
-            if _controller_type is None or not isinstance(_controller_type, type):
-                raise Exception("Operation must have a single control type.")
-            return t.cast(t.Type, _controller_type)
 
         return self._controller_type
 

ellar/core/routing/controller/base.py

@@ -6,17 +6,8 @@
 
 
 class ControllerRouteOperationBase:
-    _controller_type: t.Optional[t.Type["ControllerBase"]] = None
-    endpoint: t.Callable
     get_controller_type: t.Callable
 
-    def __init__(
-        self, controller_type: t.Type[ControllerBase], *args: t.Any, **kwargs: t.Any
-    ) -> None:
-        self._controller_type = controller_type
-
-        super().__init__(*args, **kwargs)
-
     def _get_controller_instance(self, ctx: IExecutionContext) -> ControllerBase:
         request_logger.debug("Getting Controller Instance")
         controller_type: t.Type[ControllerBase] = self.get_controller_type()