Merge pull request #53 from eadwinCode/asgi_send_fix

Removed ASGI args from contextvar

Author: eadwinCode

docs/index.md

@@ -50,7 +50,7 @@ then, start the app with:
 $(venv) ellar runserver --reload
 ```
 
-Open your browser and navigate to [`http://localhost:3000/`](http://localhost:3000/).
+Open your browser and navigate to [`http://localhost:8000/`](http://localhost:8000/).
 ![Swagger UI](img/ellar_framework.png)
 
 ## Features Summary
@@ -76,6 +76,7 @@ Open your browser and navigate to [`http://localhost:3000/`](http://localhost:30
 Project is still in development
 
 - Documentation - in progress
+- Interceptors  -  [Aspect Oriented Programming](https://en.wikipedia.org/wiki/Aspect-oriented_programming) (AOP) technique
 - Database Plugin with [Encode/ORM](https://github.com/encode/orm)
 - Caching 
 - API Throttling

ellar/asgi_args.py

@@ -1,19 +1,15 @@
 import typing as t
 
-from ellar.types import TReceive, TScope, TSend
-
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.di.providers import Provider
 
 
-class ASGIArgs:
-    __slots__ = ("scope", "receive", "send", "context")
+class RequestScopeContext:
+    __slots__ = ("_injector_scoped_context",)
 
-    def __init__(self, scope: TScope, receive: TReceive, send: TSend) -> None:
-        self.scope = scope
-        self.receive = receive
-        self.send = send
-        self.context: t.Dict[t.Type, "Provider"] = {}
+    def __init__(self) -> None:
+        self._injector_scoped_context: t.Dict[t.Type, "Provider"] = {}
 
-    def get_args(self) -> t.Tuple[TScope, TReceive, TSend]:
-        return self.scope, self.receive, self.send
+    @property
+    def context(self) -> t.Dict[t.Type, "Provider"]:
+        return self._injector_scoped_context

ellar/common/decorators/controller.py

@@ -1,6 +1,7 @@
 import inspect
 import typing as t
 from abc import ABC
+from types import FunctionType
 
 from ellar.compatible import AttributeDict
 from ellar.constants import (
@@ -14,16 +15,21 @@
 from ellar.core import ControllerBase
 from ellar.core.controller import ControllerType
 from ellar.core.exceptions import ImproperConfiguration
+from ellar.core.routing.controller import ControllerRouteOperationBase
 from ellar.di import RequestScope, injectable
 from ellar.reflect import reflect
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.guard import GuardCanActivate
 
 
-def get_route_functions(cls: t.Type) -> t.Iterable[t.Callable]:
+def get_route_functions(
+    cls: t.Type,
+) -> t.Iterable[t.Union[t.Callable, ControllerRouteOperationBase]]:
     for method in cls.__dict__.values():
-        if hasattr(method, OPERATION_ENDPOINT_KEY):
+        if hasattr(method, OPERATION_ENDPOINT_KEY) or isinstance(
+            method, ControllerRouteOperationBase
+        ):
             yield method
 
 
@@ -33,8 +39,12 @@ def reflect_all_controller_type_routes(cls: t.Type[ControllerBase]) -> None:
     for base_cls in reversed(bases):
         if base_cls not in [ABC, ControllerBase, object]:
             for item in get_route_functions(base_cls):
-                operation = reflect.get_metadata(CONTROLLER_OPERATION_HANDLER_KEY, item)
-                reflect.define_metadata(CONTROLLER_CLASS_KEY, cls, item)
+                operation = item
+                if callable(item) and type(item) == FunctionType:
+                    operation = reflect.get_metadata(  # type: ignore
+                        CONTROLLER_OPERATION_HANDLER_KEY, item
+                    )
+                reflect.define_metadata(CONTROLLER_CLASS_KEY, cls, operation.endpoint)  # type: ignore
                 reflect.define_metadata(
                     CONTROLLER_OPERATION_HANDLER_KEY,
                     operation,

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/compatible/contextmanager.py

@@ -1,6 +1,6 @@
 import sys
 
 if sys.version_info >= (3, 7):  # pragma: no cover
-    from contextlib import asynccontextmanager as asynccontextmanager  # noqa
-else:
+    from contextlib import asynccontextmanager as asynccontextmanager
+else:  # pragma: no cover
     from contextlib2 import asynccontextmanager as asynccontextmanager  # noqa

ellar/compatible/dict.py

@@ -41,13 +41,13 @@ def __getitem__(self, k: KT) -> VT:
     def __len__(self) -> int:
         return self._data.__len__()
 
-    def __iter__(self) -> t.Iterator[VT]:
+    def __iter__(self) -> t.Iterator[VT]:  # pragma: no cover
         return iter(self._data)
 
 
 class DataMutableMapper(DataMapper, t.MutableMapping[KT, VT]):
     def __setitem__(self, k: KT, v: VT) -> None:
         self._data.__setitem__(k, v)
 
-    def __delitem__(self, v: KT) -> None:
+    def __delitem__(self, v: KT) -> None:  # pragma: no cover
         self._data.__delitem__(v)

ellar/constants.py

@@ -11,12 +11,12 @@
     SHAPE_TUPLE_ELLIPSIS,
 )
 
-from .asgi_args import ASGIArgs
+from .asgi_args import RequestScopeContext
 
-ASGI_CONTEXT_VAR: contextvars.ContextVar[Optional[ASGIArgs]] = contextvars.ContextVar(
-    "ASGI-CONTEXT-VAR"
-)
-ASGI_CONTEXT_VAR.set(None)
+SCOPED_CONTEXT_VAR: contextvars.ContextVar[
+    Optional[RequestScopeContext]
+] = contextvars.ContextVar("SCOPED-CONTEXT-VAR")
+SCOPED_CONTEXT_VAR.set(None)
 
 
 class _AnnotationToValue(type):
@@ -26,7 +26,7 @@ class _AnnotationToValue(type):
     def __new__(mcls, name, bases, namespace):
         cls = super().__new__(mcls, name, bases, namespace)
         annotations = dict()
-        for base in reversed(bases):
+        for base in reversed(bases):  # pragma: no cover
             annotations.update(getattr(base, "__annotations__", {}))
         annotations.update(namespace.get("__annotations__", {}))
         cls.keys = []
@@ -49,9 +49,8 @@ def __new__(mcls, name, bases, namespace):
 ROUTE_METHODS = [POST, PUT, PATCH, DELETE, GET, HEAD, OPTIONS, TRACE]
 
 SCOPE_SERVICE_PROVIDER = "SERVICE_PROVIDER"
-SCOPE_EXECUTION_CONTEXT_PROVIDER = "SERVICE_EXECUTION_CONTEXT_PROVIDER"
-SCOPE_HOST_CONTEXT_PROVIDER = "SCOPE_HOST_CONTEXT_PROVIDER"
-SCOPE_RESPONSE_STARTED = "response_started"
+SCOPE_RESPONSE_STARTED = "__response_started__"
+SCOPED_RESPONSE = "__response__"
 SCOPE_API_VERSIONING_RESOLVER = "API_VERSIONING_RESOLVER"
 SCOPE_API_VERSIONING_SCHEME = "API_VERSIONING_SCHEME"
 ELLAR_CONFIG_MODULE = "ELLAR_CONFIG_MODULE"

ellar/core/context/__init__.py

@@ -7,7 +7,9 @@
     IExecutionContextFactory,
     IHostContext,
     IHostContextFactory,
+    IHTTPConnectionContextFactory,
     IHTTPHostContext,
+    IWebSocketContextFactory,
     IWebSocketHostContext,
 )
 
@@ -23,4 +25,6 @@
     "IHostContextFactory",
     "ExecutionContextFactory",
     "HostContextFactory",
+    "IHTTPConnectionContextFactory",
+    "IWebSocketContextFactory",
 ]