Refactored route function parameters inject functions

Author: eadwinCode

ellar/common/routing/params.py

@@ -1,16 +1,20 @@
 import typing as t
 
-from pydantic.error_wrappers import ErrorWrapper
 from pydantic.fields import Undefined
 from starlette.responses import Response
 
 from ellar.core.connection import HTTPConnection, Request, WebSocket
 from ellar.core.context import IExecutionContext
 from ellar.core.params import params
-from ellar.core.params.resolvers import (
-    BaseRequestRouteParameterResolver,
-    NonFieldRouteParameterResolver,
-    ParameterInjectable,
+from ellar.core.params.resolvers.non_parameter import (
+    ConnectionParam,
+    ExecutionContextParameter,
+    HostRequestParam,
+    ProviderParameterInjector,
+    RequestParameter,
+    ResponseRequestParam,
+    SessionRequestParam,
+    WebSocketParameter,
 )
 from ellar.types import T
 
@@ -341,108 +345,44 @@ def WsBody(
     )
 
 
-class _RequestParameter(NonFieldRouteParameterResolver):
-    async def resolve(
-        self, ctx: IExecutionContext, **kwargs: t.Any
-    ) -> t.Tuple[t.Dict, t.List]:
-        try:
-            request = ctx.switch_to_http_connection().get_request()
-            return {self.parameter_name: request}, []
-        except Exception as ex:
-            return {}, [ErrorWrapper(ex, loc=self.parameter_name or "request")]
-
-
-class _WebSocketParameter(NonFieldRouteParameterResolver):
-    async def resolve(
-        self, ctx: IExecutionContext, **kwargs: t.Any
-    ) -> t.Tuple[t.Dict, t.List]:
-        try:
-            websocket = ctx.switch_to_websocket().get_client()
-            return {self.parameter_name: websocket}, []
-        except Exception as ex:
-            return {}, [ErrorWrapper(ex, loc=self.parameter_name or "websocket")]
-
-
-class _ExecutionContextParameter(NonFieldRouteParameterResolver):
-    async def resolve(
-        self, ctx: IExecutionContext, **kwargs: t.Any
-    ) -> t.Tuple[t.Dict, t.List]:
-        return {self.parameter_name: ctx}, []
-
-
-class _HostRequestParam(BaseRequestRouteParameterResolver):
-    lookup_connection_field = None
-
-    async def get_value(self, ctx: IExecutionContext) -> t.Any:
-        connection = ctx.switch_to_http_connection().get_client()
-        if connection.client:
-            return connection.client.host
-
-
-class _SessionRequestParam(BaseRequestRouteParameterResolver):
-    lookup_connection_field = "session"
-
-
-class _ConnectionParam(NonFieldRouteParameterResolver):
-    async def resolve(
-        self, ctx: IExecutionContext, **kwargs: t.Any
-    ) -> t.Tuple[t.Dict, t.List]:
-        try:
-            connection = ctx.switch_to_http_connection().get_client()
-            return {self.parameter_name: connection}, []
-        except Exception as ex:
-            return {}, [ErrorWrapper(ex, loc=self.parameter_name or "connection")]
-
-
-class _ResponseRequestParam(NonFieldRouteParameterResolver):
-    async def resolve(
-        self, ctx: IExecutionContext, **kwargs: t.Any
-    ) -> t.Tuple[t.Dict, t.List]:
-        try:
-            response = ctx.switch_to_http_connection().get_response()
-            return {self.parameter_name: response}, []
-        except Exception as ex:
-            return {}, [ErrorWrapper(ex, loc=self.parameter_name or "response")]
-
-
 def Http() -> HTTPConnection:
     """
     Route Function Parameter for retrieving Current Request Instance
     :return: Request
     """
-    return t.cast(Request, _ConnectionParam())
+    return t.cast(Request, ConnectionParam())
 
 
 def Req() -> Request:
     """
     Route Function Parameter for retrieving Current Request Instance
     :return: Request
     """
-    return t.cast(Request, _RequestParameter())
+    return t.cast(Request, RequestParameter())
 
 
 def Ws() -> WebSocket:
     """
     Route Function Parameter for retrieving Current WebSocket Instance
     :return: WebSocket
     """
-    return t.cast(WebSocket, _WebSocketParameter())
+    return t.cast(WebSocket, WebSocketParameter())
 
 
 def Context() -> IExecutionContext:
     """
     Route Function Parameter for retrieving Current IExecutionContext Instance
     :return: IExecutionContext
     """
-    return t.cast(IExecutionContext, _ExecutionContextParameter())
+    return t.cast(IExecutionContext, ExecutionContextParameter())
 
 
 def Provide(service: t.Optional[t.Type[T]] = None) -> T:
     """
     Route Function Parameter for resolving registered Provider
     :return: T
     """
-    return t.cast(T, ParameterInjectable(service))
+    return t.cast(T, ProviderParameterInjector(service))
 
 
 def Session() -> t.Dict:
@@ -451,20 +391,20 @@ def Session() -> t.Dict:
     Ensure SessionMiddleware is registered to application middlewares
     :return: Dict
     """
-    return t.cast(t.Dict, _SessionRequestParam())
+    return t.cast(t.Dict, SessionRequestParam())
 
 
 def Host() -> str:
     """
     Route Function Parameter for resolving registered `HTTPConnection.client.host`
     :return: str
     """
-    return t.cast(str, _HostRequestParam())
+    return t.cast(str, HostRequestParam())
 
 
 def Res() -> Response:
     """
     Route Function Parameter for resolving registered Response
     :return: Response
     """
-    return t.cast(Response, _ResponseRequestParam())
+    return t.cast(Response, ResponseRequestParam())

ellar/core/params/__init__.py

@@ -6,19 +6,19 @@
 )
 from .params import Body, Cookie, File, Form, Header, Param, ParamTypes, Path, Query
 from .resolvers import (
-    BaseRequestRouteParameterResolver,
-    BaseRouteParameterResolver,
-    NonFieldRouteParameterResolver,
+    BaseConnectionParameterResolver,
+    IRouteParameterResolver,
+    NonParameterResolver,
 )
 
 __all__ = [
     "WebsocketEndpointArgsModel",
     "RequestEndpointArgsModel",
     "ExtraEndpointArg",
     "EndpointArgsModel",
-    "NonFieldRouteParameterResolver",
-    "BaseRequestRouteParameterResolver",
-    "BaseRouteParameterResolver",
+    "NonParameterResolver",
+    "BaseConnectionParameterResolver",
+    "IRouteParameterResolver",
     "Body",
     "Cookie",
     "File",

ellar/core/params/args/base.py

@@ -26,9 +26,15 @@
 from ..helpers import is_scalar_field, is_scalar_sequence_field
 from ..resolvers import (
     BaseRouteParameterResolver,
-    NonFieldRouteParameterResolver,
-    ParameterInjectable,
-    RouteParameterResolver,
+    IRouteParameterResolver,
+    NonParameterResolver,
+)
+from ..resolvers.non_parameter import (
+    ConnectionParam,
+    ExecutionContextParameter,
+    RequestParameter,
+    ResponseRequestParam,
+    WebSocketParameter,
 )
 from .extra_args import ExtraEndpointArg
 from .factory import get_parameter_field
@@ -39,6 +45,24 @@
     QueryHeaderResolverGenerator,
 )
 
+DEFAULT_RESOLVERS: t.Dict[t.Type, t.Type[NonParameterResolver]] = {
+    Request: RequestParameter,
+    StarletteRequest: RequestParameter,
+    WebSocket: WebSocketParameter,
+    StarletteWebSocket: WebSocketParameter,
+    Response: ResponseRequestParam,
+    HTTPConnection: ConnectionParam,
+    StarletteHTTPConnection: ConnectionParam,
+    IExecutionContext: ExecutionContextParameter,
+    ExecutionContext: ExecutionContextParameter,
+}
+
+
+def add_default_resolver(
+    type_identifier: t.Type, resolver_type: t.Type[NonParameterResolver]
+) -> None:
+    DEFAULT_RESOLVERS.update({type_identifier: resolver_type})
+
 
 class EndpointArgsModel:
     _bulk_resolvers_generators = {
@@ -72,12 +96,14 @@ def __init__(
         self.path = path
         self.param_converters = param_converters
         self._computation_models: t.DefaultDict[
-            str, t.List[BaseRouteParameterResolver]
+            str, t.List[IRouteParameterResolver]
         ] = defaultdict(list)
         self.path_param_names = self.get_path_param_names(path)
         self.endpoint_signature = self.get_typed_signature(endpoint)
-        self.body_resolver: t.Optional[t.Union[t.Any, RouteParameterResolver]] = None
-        self._route_models: t.List[BaseRouteParameterResolver] = []
+        self.body_resolver: t.Optional[
+            t.Union[t.Any, BaseRouteParameterResolver]
+        ] = None
+        self._route_models: t.List[IRouteParameterResolver] = []
         self._extra_endpoint_args: t.List[ExtraEndpointArg] = (
             list(extra_endpoint_args) if extra_endpoint_args else []
         )
@@ -89,14 +115,14 @@ def get_resolver_generator(
             str(type(param)), BulkArgsResolverGenerator
         )
 
-    def get_route_models(self) -> t.List[BaseRouteParameterResolver]:
+    def get_route_models(self) -> t.List[IRouteParameterResolver]:
         """
         Returns all computed endpoint resolvers required for function execution
         :return: List[BaseRouteParameterResolver]
         """
         return self._route_models
 
-    def get_all_models(self) -> t.List[BaseRouteParameterResolver]:
+    def get_all_models(self) -> t.List[IRouteParameterResolver]:
         """
         Returns all computed endpoint resolvers + omitted resolvers
         :return: List[BaseRouteParameterResolver]
@@ -150,7 +176,7 @@ def build_model(self) -> None:
             + self._computation_models[params.Path.in_.value]
             + self._computation_models[params.Query.in_.value]
             + self._computation_models[params.Cookie.in_.value]
-            + self._computation_models[NonFieldRouteParameterResolver.in_]
+            + self._computation_models[NonParameterResolver.in_]
         )
 
     def compute_route_parameter_list(
@@ -236,7 +262,7 @@ def _add_non_field_param_to_dependency(
         param_annotation: t.Optional[t.Type],
         key: str = None,
     ) -> t.Optional[bool]:
-        if isinstance(param_default, NonFieldRouteParameterResolver):
+        if isinstance(param_default, NonParameterResolver):
             model = param_default(param_name, param_annotation)  # type:ignore
             self._computation_models[key or model.in_].append(model)
             return True
@@ -349,22 +375,9 @@ def build_body_field(self) -> None:
     def _add_non_pydantic_field_to_dependency(
         self, param_name: str, param_default: t.Any, param_annotation: t.Any
     ) -> bool:
-        if (
-            param_annotation
-            in (
-                Request,
-                WebSocket,
-                HTTPConnection,
-                Response,
-                StarletteRequest,
-                StarletteHTTPConnection,
-                IExecutionContext,
-                ExecutionContext,
-                StarletteWebSocket,
-            )
-            and param_default == inspect.Parameter.empty
-        ):
-            _inject = ParameterInjectable()(param_name, param_annotation)
+        resolver_class = DEFAULT_RESOLVERS.get(param_annotation)
+        if resolver_class and param_default == inspect.Parameter.empty:
+            _inject = resolver_class()(param_name, param_annotation)
             self._computation_models[_inject.in_].append(_inject)
             return True
         return False

ellar/core/params/args/extra_args.py

@@ -5,6 +5,45 @@
 
 
 class ExtraEndpointArg(t.Generic[T]):
+    """
+    Add more route function parameters programmatically.
+    For example:
+    lets add `limit` and `offset` to a route function.
+
+    def limit(func):
+        limit_args = ExtraEndpointArg(name='limit', annotation=int, default_value=10)
+
+        offset_args = ExtraEndpointArg(name='offset', annotation=int, default_value=0)
+
+        extra_args = [limit_args, offset_args]
+
+        set_metadata(EXTRA_ROUTE_ARGS_KEY, extra_args)(func)
+
+        @wraps(func)
+        def _wrapper(*args, **kwargs):
+            # RESOLVING EXTRA ARGS
+
+            resolved_limit_args = limit_args.resolve(kwargs)
+
+            resolved_offset_args = offset_args.resolve(kwargs)
+
+            response = func(*args, **kwargs)
+
+            response = response[resolved_offset_args: resolved_limit_args]
+
+            return response
+
+        return _wrapper
+
+    router = ModuleRouter('/testing')
+
+    @router.get('/list')
+    @limit
+    def route(request: Request):
+
+        return [i=1 for i in range(40)]
+    """
+
     __slots__ = ("name", "annotation", "default")
 
     empty = inspect.Parameter.empty

ellar/core/params/args/request_model.py

@@ -8,7 +8,7 @@
 from ellar.helper.modelfield import create_model_field
 
 from .. import params
-from ..resolvers import RouteParameterResolver
+from ..resolvers import BaseRouteParameterResolver
 from .base import EndpointArgsModel
 from .extra_args import ExtraEndpointArg
 
@@ -56,7 +56,7 @@ def build_body_field(self) -> None:
         elif body_resolvers:
             # if body_resolvers is more than one, we create a bulk_body_resolver instead
             _body_resolvers_model_fields = (
-                t.cast(RouteParameterResolver, item).model_field
+                t.cast(BaseRouteParameterResolver, item).model_field
                 for item in body_resolvers
             )
             model_name = "body_" + self.operation_unique_id