Removed Request, response, websocket, executioncontext from been inject by injector.

Author: eadwinCode

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",
 ]

ellar/core/context/factory.py

@@ -1,11 +1,10 @@
 import typing as t
-from abc import ABC, abstractmethod
 
-from ellar.constants import ASGI_CONTEXT_VAR
-from ellar.di import injectable
+from ellar.constants import SCOPED_CONTEXT_VAR
+from ellar.di import injectable, request_scope
 from ellar.di.exceptions import ServiceUnavailable
 from ellar.services import Reflector
-from ellar.types import T, TReceive, TScope, TSend
+from ellar.types import TReceive, TScope, TSend
 
 from .exceptions import HostContextException
 from .execution import ExecutionContext
@@ -16,41 +15,18 @@
     IExecutionContextFactory,
     IHostContext,
     IHostContextFactory,
+    IHTTPConnectionContextFactory,
+    IWebSocketContextFactory,
+    empty_receive,
+    empty_send,
 )
 from .websocket import WebSocketHostContext
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.routing import RouteOperationBase
 
 
-class SubHostContextFactory(t.Generic[T], ABC):
-    """
-    Factory for creating HostContext types and validating them.
-    """
-
-    context_type: t.Type[T]
-
-    __slots__ = ()
-
-    @injectable()
-    def __call__(self, context: IHostContext) -> T:
-        self.validate(context)
-        return self.create_context_type(context)
-
-    @abstractmethod
-    def validate(self, context: IHostContext) -> None:
-        pass
-
-    def create_context_type(self, context: IHostContext) -> T:
-        scope, receive, send = context.get_args()
-        return self.context_type(  # type:ignore
-            scope=scope,
-            receive=receive,
-            send=send,
-        )
-
-
-class HTTPConnectionContextFactory(SubHostContextFactory[HTTPHostContext]):
+class HTTPConnectionContextFactory(IHTTPConnectionContextFactory):
     context_type = HTTPHostContext
 
     def validate(self, context: IHostContext) -> None:
@@ -62,7 +38,7 @@ def validate(self, context: IHostContext) -> None:
         pass
 
 
-class WebSocketContextFactory(SubHostContextFactory[WebSocketHostContext]):
+class WebSocketContextFactory(IWebSocketContextFactory):
     context_type = WebSocketHostContext
 
     def validate(self, context: IHostContext) -> None:
@@ -72,25 +48,18 @@ def validate(self, context: IHostContext) -> None:
             )
 
 
-@injectable()
+@injectable(scope=request_scope)
 class HostContextFactory(IHostContextFactory):
     __slots__ = ()
 
-    def create_context(self) -> IHostContext:
-        scoped_request_args = ASGI_CONTEXT_VAR.get()
-
-        if not scoped_request_args:
-            raise ServiceUnavailable()
-
-        scope, receive, send = scoped_request_args.get_args()
+    def create_context(
+        self, scope: TScope, receive: TReceive = empty_receive, send: TSend = empty_send
+    ) -> IHostContext:
         host_context = HostContext(scope=scope, receive=receive, send=send)
-        host_context.get_service_provider().update_scoped_context(
-            IHostContext, host_context  # type: ignore
-        )
         return host_context
 
 
-@injectable()
+@injectable(scope=request_scope)
 class ExecutionContextFactory(IExecutionContextFactory):
     __slots__ = ("reflector",)
 
@@ -101,10 +70,10 @@ def create_context(
         self,
         operation: "RouteOperationBase",
         scope: TScope,
-        receive: TReceive,
-        send: TSend,
+        receive: TReceive = empty_receive,
+        send: TSend = empty_send,
     ) -> IExecutionContext:
-        scoped_request_args = ASGI_CONTEXT_VAR.get()
+        scoped_request_args = SCOPED_CONTEXT_VAR.get()
 
         if not scoped_request_args:
             raise ServiceUnavailable()
@@ -116,8 +85,5 @@ def create_context(
             operation_handler=operation.endpoint,
             reflector=self.reflector,
         )
-        i_execution_context.get_service_provider().update_scoped_context(
-            IExecutionContext, i_execution_context  # type: ignore
-        )
 
         return i_execution_context

ellar/core/context/host.py

@@ -4,7 +4,13 @@
 from ellar.constants import SCOPE_SERVICE_PROVIDER
 from ellar.types import TReceive, TScope, TSend
 
-from .interface import IHostContext, IHTTPHostContext, IWebSocketHostContext
+from .interface import (
+    IHostContext,
+    IHTTPConnectionContextFactory,
+    IHTTPHostContext,
+    IWebSocketContextFactory,
+    IWebSocketHostContext,
+)
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.main import App
@@ -36,11 +42,25 @@ def get_service_provider(self) -> "EllarInjector":
     def _service_provider(self) -> "EllarInjector":
         return self.scope[SCOPE_SERVICE_PROVIDER]  # type:ignore
 
+    @cached_property
+    def _get_websocket_context(self) -> IWebSocketHostContext:
+        ws_context_factory: IWebSocketContextFactory = self.get_service_provider().get(
+            IWebSocketContextFactory
+        )
+        return ws_context_factory(self)
+
+    @cached_property
+    def _get_http_context(self) -> IHTTPHostContext:
+        http_context_factory: IHTTPConnectionContextFactory = (
+            self.get_service_provider().get(IHTTPConnectionContextFactory)
+        )
+        return http_context_factory(self)
+
     def switch_to_http_connection(self) -> IHTTPHostContext:
-        return self.get_service_provider().get(IHTTPHostContext)  # type: ignore
+        return self._get_http_context  # type: ignore
 
     def switch_to_websocket(self) -> IWebSocketHostContext:
-        return self.get_service_provider().get(IWebSocketHostContext)  # type: ignore
+        return self._get_websocket_context  # type: ignore
 
     def get_type(self) -> str:
         return str(self.scope["type"])

ellar/core/context/http.py

@@ -4,6 +4,7 @@
 from starlette.responses import Response
 
 from ellar.compatible import cached_property
+from ellar.constants import SCOPED_RESPONSE
 from ellar.core.connection import HTTPConnection, Request
 from ellar.types import TReceive, TScope, TSend
 
@@ -43,22 +44,22 @@ def _request(self) -> Request:
 
     @property
     def has_response(self) -> bool:
-        return self._response is not None
+        return SCOPED_RESPONSE in self.scope
 
     def get_response(self) -> Response:
-        if not self._response:
+        if SCOPED_RESPONSE not in self.scope:
             if self.scope["type"] != "http":
                 raise HostContextException(
                     f"Response is not allow for connection type scope[type]={self.scope['type']}"
                 )
 
-            self._response = Response(
+            self.scope[SCOPED_RESPONSE] = Response(
                 background=BackgroundTasks(),
                 content=None,
                 status_code=-100,
             )
 
-        return self._response
+        return t.cast(Response, self.scope[SCOPED_RESPONSE])
 
     def get_request(self) -> Request:
         return self._request  # type: ignore

ellar/core/context/interface.py

@@ -3,7 +3,7 @@
 
 from ellar.core.connection import HTTPConnection, Request, WebSocket
 from ellar.core.response import Response
-from ellar.types import TReceive, TScope, TSend
+from ellar.types import T, TMessage, TReceive, TScope, TSend
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core import ControllerBase
@@ -12,6 +12,14 @@
     from ellar.di.injector import EllarInjector
 
 
+async def empty_receive() -> t.NoReturn:
+    raise RuntimeError("Receive channel has not been made available")
+
+
+async def empty_send(message: TMessage) -> t.NoReturn:
+    raise RuntimeError("Send channel has not been made available")
+
+
 class IHTTPHostContext(ABC):
     @property
     @abstractmethod
@@ -75,7 +83,12 @@ def get_class(self) -> t.Optional[t.Type["ControllerBase"]]:
 
 class IHostContextFactory(ABC):
     @abstractmethod
-    def create_context(self) -> IHostContext:
+    def create_context(
+        self,
+        scope: TScope,
+        receive: TReceive = empty_receive,
+        send: TSend = empty_send,
+    ) -> IHostContext:
         pass
 
 
@@ -85,7 +98,41 @@ def create_context(
         self,
         operation: "RouteOperationBase",
         scope: TScope,
-        receive: TReceive,
-        send: TSend,
+        receive: TReceive = empty_receive,
+        send: TSend = empty_send,
     ) -> IExecutionContext:
         pass
+
+
+class SubHostContextFactory(t.Generic[T], ABC):
+    """
+    Factory for creating HostContext types and validating them.
+    """
+
+    context_type: t.Type[T]
+
+    __slots__ = ()
+
+    def __call__(self, context: IHostContext) -> T:
+        self.validate(context)
+        return self.create_context_type(context)
+
+    @abstractmethod
+    def validate(self, context: IHostContext) -> None:
+        pass
+
+    def create_context_type(self, context: IHostContext) -> T:
+        scope, receive, send = context.get_args()
+        return self.context_type(  # type:ignore
+            scope=scope,
+            receive=receive,
+            send=send,
+        )
+
+
+class IHTTPConnectionContextFactory(SubHostContextFactory[IHTTPHostContext], ABC):
+    context_typ: t.Type[IHTTPHostContext]
+
+
+class IWebSocketContextFactory(SubHostContextFactory[IWebSocketHostContext], ABC):
+    context_type: t.Type[IWebSocketHostContext]

ellar/core/middleware/exceptions.py

@@ -3,7 +3,7 @@
 from starlette.exceptions import HTTPException
 
 from ellar.constants import SCOPE_SERVICE_PROVIDER
-from ellar.core.context import IHostContext
+from ellar.core.context import IHostContextFactory
 from ellar.types import ASGIApp, TMessage, TReceive, TScope, TSend
 
 if t.TYPE_CHECKING:  # pragma: no cover
@@ -35,7 +35,6 @@ async def sender(message: TMessage) -> None:
             if message["type"] == "http.response.start":
                 response_started = True
             await send(message)
-            return
 
         try:
             await self.app(scope, receive, sender)
@@ -63,7 +62,8 @@ async def sender(message: TMessage) -> None:
                 "EllarInjector", scope[SCOPE_SERVICE_PROVIDER]
             )
 
-            context = service_provider.get(IHostContext)
+            context_factory = service_provider.get(IHostContextFactory)
+            context = context_factory.create_context(scope)
 
             if context.get_type() == "http":
                 response = await handler.catch(context, exc)
@@ -72,4 +72,5 @@ async def sender(message: TMessage) -> None:
                     raise RuntimeError(msg) from exc
                 await response(scope, receive, sender)
             elif context.get_type() == "websocket":
-                await handler.catch(context, exc)
+                ws_context = context_factory.create_context(scope, receive, send)
+                await handler.catch(ws_context, exc)

ellar/core/middleware/function.py

@@ -3,7 +3,7 @@
 from starlette.responses import Response
 
 from ellar.core.connection import HTTPConnection
-from ellar.core.context import IHostContext
+from ellar.core.context import IHostContext, IHostContextFactory
 from ellar.types import ASGIApp, TReceive, TScope, TSend
 
 AwaitableCallable = t.Callable[..., t.Awaitable]
@@ -56,7 +56,8 @@ async def __call__(self, scope: TScope, receive: TReceive, send: TSend) -> None:
         if not connection.service_provider:  # pragma: no cover
             raise Exception("Service Provider is required")
 
-        context = connection.service_provider.get(IHostContext)
+        context_factory = connection.service_provider.get(IHostContextFactory)
+        context = context_factory.create_context(scope, receive, send)
 
         async def call_next() -> None:
             await self.app(scope, receive, send)

ellar/core/params/resolvers/__init__.py

@@ -0,0 +1,40 @@
+from .base import (
+    BaseRouteParameterResolver,
+    IRouteParameterResolver,
+    RouteParameterModelField,
+)
+from .bulk_parameter import (
+    BulkBodyParameterResolver,
+    BulkFormParameterResolver,
+    BulkParameterResolver,
+)
+from .non_parameter.base import BaseConnectionParameterResolver, NonParameterResolver
+from .parameter import (
+    BodyParameterResolver,
+    CookieParameterResolver,
+    FileParameterResolver,
+    FormParameterResolver,
+    HeaderParameterResolver,
+    PathParameterResolver,
+    QueryParameterResolver,
+    WsBodyParameterResolver,
+)
+
+__all__ = [
+    "IRouteParameterResolver",
+    "RouteParameterModelField",
+    "BaseRouteParameterResolver",
+    "BodyParameterResolver",
+    "WsBodyParameterResolver",
+    "FormParameterResolver",
+    "PathParameterResolver",
+    "CookieParameterResolver",
+    "HeaderParameterResolver",
+    "BulkParameterResolver",
+    "BulkBodyParameterResolver",
+    "BulkFormParameterResolver",
+    "QueryParameterResolver",
+    "FileParameterResolver",
+    "NonParameterResolver",
+    "BaseConnectionParameterResolver",
+]