Renamed NonParameterResolver to SystemParameterResolver

Author: ¨eadwinCode¨

docs/overview/custom_decorators.md

@@ -181,12 +181,12 @@ As shown in the return statements in the example below.
 For example:
 ```python
 import typing as t
-from ellar.common.params import NonParameterResolver
+from ellar.common.params import SystemParameterResolver
 from ellar.common import IExecutionContext
 from pydantic.error_wrappers import ErrorWrapper
 
 
-class UserParam(NonParameterResolver):
+class UserParam(SystemParameterResolver):
     async def resolve(self, ctx: IExecutionContext, **kwargs: t.Any) -> t.Any:
         request = ctx.switch_to_http_connection().get_request()
         user = request.get('user', None)

ellar/common/params/__init__.py

@@ -8,7 +8,7 @@
 from .resolvers import (
     BaseConnectionParameterResolver,
     IRouteParameterResolver,
-    NonParameterResolver,
+    SystemParameterResolver,
 )
 
 __all__ = [
@@ -17,7 +17,7 @@
     "RequestEndpointArgsModel",
     "ExtraEndpointArg",
     "EndpointArgsModel",
-    "NonParameterResolver",
+    "SystemParameterResolver",
     "BaseConnectionParameterResolver",
     "IRouteParameterResolver",
 ]

ellar/common/params/args/base.py

@@ -24,7 +24,7 @@
 from ..resolvers import (
     BaseRouteParameterResolver,
     IRouteParameterResolver,
-    NonParameterResolver,
+    SystemParameterResolver,
 )
 from .extra_args import ExtraEndpointArg
 from .factory import get_parameter_field
@@ -148,7 +148,7 @@ def build_model(self) -> None:
             + self._computation_models[params.PathFieldInfo.in_.value]
             + self._computation_models[params.QueryFieldInfo.in_.value]
             + self._computation_models[params.CookieFieldInfo.in_.value]
-            + self._computation_models[NonParameterResolver.in_]
+            + self._computation_models[SystemParameterResolver.in_]
         )
 
     def compute_route_parameter_list(
@@ -182,7 +182,7 @@ def compute_route_parameter_list(
             ):
                 continue
 
-            if self._add_non_field_param_to_dependency(
+            if self._add_system_parameters_to_dependency(
                 param_name=param_name,
                 param_default=param_default,
                 param_annotation=param_annotation,
@@ -236,15 +236,15 @@ def compute_route_parameter_list(
                         )
                 self._add_to_model(field=param_field)
 
-    def _add_non_field_param_to_dependency(
+    def _add_system_parameters_to_dependency(
         self,
         *,
         param_default: t.Any,
         param_name: str,
         param_annotation: t.Optional[t.Type],
         key: t.Optional[str] = None,
     ) -> t.Optional[bool]:
-        if isinstance(param_default, NonParameterResolver):
+        if isinstance(param_default, SystemParameterResolver):
             model = param_default(param_name, param_annotation)  # type:ignore
             self._computation_models[key or model.in_].append(model)
             return True
@@ -340,7 +340,7 @@ def _add_extra_route_args(
                 param_annotation, param_default
             )
 
-            if self._add_non_field_param_to_dependency(
+            if self._add_system_parameters_to_dependency(
                 param_name=param_name,
                 param_default=param_default,
                 param_annotation=param_annotation,

ellar/common/params/decorators/inject.py

@@ -13,9 +13,9 @@
 from typing_extensions import Annotated
 
 from ..resolvers import (
-    NonParameterResolver,
+    SystemParameterResolver,
 )
-from ..resolvers.non_parameter import (
+from ..resolvers.system_parameters import (
     BackgroundTasksParameter,
     ConnectionParam,
     ExecutionContextParameter,
@@ -27,7 +27,7 @@
     WebSocketParameter,
 )
 
-_DEFAULT_RESOLVERS: t.Dict[t.Union[t.Type, str], t.Type[NonParameterResolver]] = {
+_DEFAULT_RESOLVERS: t.Dict[t.Union[t.Type, str], t.Type[SystemParameterResolver]] = {
     StarletteRequest: RequestParameter,
     StarletteWebSocket: WebSocketParameter,
     Response: ResponseRequestParam,
@@ -40,14 +40,15 @@
 
 
 def add_default_resolver(
-    type_identifier: t.Union[t.Type, str], resolver_type: t.Type[NonParameterResolver]
+    type_identifier: t.Union[t.Type, str],
+    resolver_type: t.Type[SystemParameterResolver],
 ) -> None:  # pragma: no cover
     _DEFAULT_RESOLVERS.update({type_identifier: resolver_type})
 
 
 def get_default_resolver(
     type_identifier: t.Union[t.Type, str]
-) -> t.Optional[t.Type[NonParameterResolver]]:
+) -> t.Optional[t.Type[SystemParameterResolver]]:
     return _DEFAULT_RESOLVERS.get(type_identifier)
 
 

ellar/common/params/resolvers/__init__.py

@@ -8,7 +8,6 @@
     BulkFormParameterResolver,
     BulkParameterResolver,
 )
-from .non_parameter.base import BaseConnectionParameterResolver, NonParameterResolver
 from .parameter import (
     BodyParameterResolver,
     CookieParameterResolver,
@@ -19,6 +18,10 @@
     QueryParameterResolver,
     WsBodyParameterResolver,
 )
+from .system_parameters.base import (
+    BaseConnectionParameterResolver,
+    SystemParameterResolver,
+)
 
 __all__ = [
     "IRouteParameterResolver",
@@ -35,6 +38,6 @@
     "BulkFormParameterResolver",
     "QueryParameterResolver",
     "FileParameterResolver",
-    "NonParameterResolver",
+    "SystemParameterResolver",
     "BaseConnectionParameterResolver",
 ]

ellar/common/params/resolvers/non_parameter/__init__.py renamed to ellar/common/params/resolvers/system_parameters/__init__.py

@@ -1,15 +1,15 @@
 from .background import BackgroundTasksParameter
-from .base import BaseConnectionParameterResolver, NonParameterResolver
+from .base import BaseConnectionParameterResolver, SystemParameterResolver
 from .connection import ConnectionParam
 from .context import ExecutionContextParameter
-from .inject import ProviderParameterInjector
+from .provider import ProviderParameterInjector
 from .request import RequestParameter
 from .response import ResponseRequestParam
 from .session import HostRequestParam, SessionRequestParam
 from .websocket import WebSocketParameter
 
 __all__ = [
-    "NonParameterResolver",
+    "SystemParameterResolver",
     "BaseConnectionParameterResolver",
     "ExecutionContextParameter",
     "RequestParameter",

ellar/common/params/resolvers/non_parameter/background.py renamed to ellar/common/params/resolvers/system_parameters/background.py

@@ -3,10 +3,10 @@
 from ellar.common.interfaces import IExecutionContext
 from starlette.background import BackgroundTask, BackgroundTasks
 
-from .base import NonParameterResolver
+from .base import SystemParameterResolver
 
 
-class BackgroundTasksParameter(NonParameterResolver):
+class BackgroundTasksParameter(SystemParameterResolver):
     async def resolve(
         self, ctx: IExecutionContext, **kwargs: t.Any
     ) -> t.Tuple[t.Dict, t.List]:

ellar/common/params/resolvers/non_parameter/base.py renamed to ellar/common/params/resolvers/system_parameters/base.py

@@ -9,12 +9,12 @@
 from ..base import IRouteParameterResolver
 
 
-class NonParameterResolver(IRouteParameterResolver, ABC):
+class SystemParameterResolver(IRouteParameterResolver, ABC):
     """
     Define extra route function parameter dependencies that does not depend on user inputs
 
     Example:
-    >>> class UserField(NonParameterResolver):
+    >>> class UserField(SystemParameterResolver):
     >>>     async def resolve(self, ctx: IExecutionContext, **kwargs: t.Any) -> t.Any:
     >>>          request = ctx.switch_to_http_connection().get_request()
     >>>          user = request.get('user', None)
@@ -27,7 +27,7 @@ class NonParameterResolver(IRouteParameterResolver, ABC):
     >>>     return user
     """
 
-    in_: str = "non_field_parameter"
+    in_: str = "system_parameter"
 
     def __init__(self, data: t.Optional[t.Any] = None):
         self.data = data
@@ -44,7 +44,7 @@ async def resolve(self, ctx: IExecutionContext, **kwargs: t.Any) -> t.Any:
         raise NotImplementedError
 
 
-class BaseConnectionParameterResolver(NonParameterResolver):
+class BaseConnectionParameterResolver(SystemParameterResolver):
     """
     Defines HTTPConnection fields resolver for route parameter based on the provided `lookup_connection_field`
     """
@@ -54,7 +54,7 @@ class BaseConnectionParameterResolver(NonParameterResolver):
 
     def __call__(
         self, parameter_name: str, parameter_annotation: t.Type[T]
-    ) -> "NonParameterResolver":
+    ) -> "SystemParameterResolver":
         result = super().__call__(parameter_name, parameter_annotation)
         if not hasattr(self, "lookup_connection_field"):
             raise Exception(f"{self.__class__.__name__}.request_field is not set")

ellar/common/params/resolvers/non_parameter/connection.py renamed to ellar/common/params/resolvers/system_parameters/connection.py

@@ -2,10 +2,10 @@
 
 from ellar.common.interfaces import IExecutionContext
 
-from .base import NonParameterResolver
+from .base import SystemParameterResolver
 
 
-class ConnectionParam(NonParameterResolver):
+class ConnectionParam(SystemParameterResolver):
     async def resolve(
         self, ctx: IExecutionContext, **kwargs: t.Any
     ) -> t.Tuple[t.Dict, t.List]:

ellar/common/params/resolvers/non_parameter/context.py renamed to ellar/common/params/resolvers/system_parameters/context.py

@@ -2,10 +2,10 @@
 
 from ellar.common.interfaces import IExecutionContext
 
-from .base import NonParameterResolver
+from .base import SystemParameterResolver
 
 
-class ExecutionContextParameter(NonParameterResolver):
+class ExecutionContextParameter(SystemParameterResolver):
     async def resolve(
         self, ctx: IExecutionContext, **kwargs: t.Any
     ) -> t.Tuple[t.Dict, t.List]: