Removed IHostContext and IExecutionContext concrete type registration

Author: eadwinCode

ellar/core/connection/http.py

@@ -16,7 +16,7 @@ class HTTPConnection(StarletteHTTPConnection):
     def service_provider(self) -> "RequestServiceProvider":
         assert (
             SCOPE_SERVICE_PROVIDER in self.scope
-        ), "DIRequestServiceProviderMiddleware must be installed to access request.service_provider"
+        ), "RequestServiceProviderMiddleware must be installed to access request.service_provider"
         return t.cast("RequestServiceProvider", self.scope[SCOPE_SERVICE_PROVIDER])
 
 

ellar/core/context/__init__.py

@@ -4,16 +4,16 @@
 from .interface import (
     IExecutionContext,
     IHostContext,
-    IHTTPConnectionHost,
-    IWebSocketConnectionHost,
+    IHTTPHostContext,
+    IWebSocketHostContext,
 )
 
 __all__ = [
     "IExecutionContext",
     "ExecutionContext",
     "IHostContext",
-    "IHTTPConnectionHost",
-    "IWebSocketConnectionHost",
+    "IHTTPHostContext",
+    "IWebSocketHostContext",
     "HostContext",
     "HostContextException",
 ]

ellar/core/context/execution.py

@@ -1,6 +1,9 @@
 import typing as t
 
+from ellar.compatible import cached_property
 from ellar.constants import CONTROLLER_CLASS_KEY, SCOPE_SERVICE_PROVIDER
+from ellar.di import injectable
+from ellar.di.providers import ModuleProvider
 from ellar.services.reflector import Reflector
 from ellar.types import TReceive, TScope, TSend
 
@@ -14,7 +17,12 @@
     from ellar.di.injector import RequestServiceProvider
 
 
+@injectable()
 class ExecutionContext(HostContext, IExecutionContext):
+    """
+    Context for route functions and controllers
+    """
+
     __slots__ = ("_operation_handler",)
 
     def __init__(
@@ -23,25 +31,24 @@ def __init__(
         scope: TScope,
         receive: TReceive,
         send: TSend,
-        operation_handler: t.Callable = None,
+        operation_handler: t.Callable,
+        reflector: Reflector,
     ) -> None:
         super(ExecutionContext, self).__init__(scope=scope, receive=receive, send=send)
         self._operation_handler = operation_handler
-
-    def set_operation(self, operation: t.Optional["RouteOperationBase"] = None) -> None:
-        if operation:
-            self._operation_handler = operation.endpoint
+        self.reflector = reflector
 
     def get_handler(self) -> t.Callable:
         assert self._operation_handler, "Operation is not available yet."
         return self._operation_handler
 
+    @cached_property
+    def _get_class(self) -> t.Optional[t.Type["ControllerBase"]]:
+        result = self.reflector.get(CONTROLLER_CLASS_KEY, self.get_handler())
+        return t.cast(t.Optional[t.Type["ControllerBase"]], result)
+
     def get_class(self) -> t.Optional[t.Type["ControllerBase"]]:
-        reflector = self.get_service_provider().get(Reflector)
-        result: t.Optional[t.Type["ControllerBase"]] = reflector.get(
-            CONTROLLER_CLASS_KEY, self.get_handler()
-        )
-        return result
+        return self._get_class  # type: ignore
 
     @classmethod
     def create_context(
@@ -50,13 +57,14 @@ def create_context(
         scope: TScope,
         receive: TReceive,
         send: TSend,
-        operation: t.Optional["RouteOperationBase"] = None,
-    ) -> "ExecutionContext":
-        execution_context = cls(
+        operation: "RouteOperationBase",
+    ) -> IExecutionContext:
+        provider = ModuleProvider(
+            cls,
             scope=scope,
             receive=receive,
             send=send,
-            operation_handler=operation.endpoint if operation else None,
+            operation_handler=operation.endpoint,
         )
         request_provider: "RequestServiceProvider" = t.cast(
             "RequestServiceProvider", scope.get(SCOPE_SERVICE_PROVIDER)
@@ -67,8 +75,7 @@ def create_context(
                 "Please ensure `RequestServiceProviderMiddleware` is registered."
             )
 
-        request_provider.update_context(
-            t.cast(t.Type, IExecutionContext), execution_context
-        )
-        request_provider.update_context(cls, execution_context)
+        request_provider.update_context(IExecutionContext, provider)
+        execution_context = request_provider.get(IExecutionContext)  # type: ignore
+
         return execution_context

ellar/core/context/factory.py

@@ -4,12 +4,16 @@
 from ellar.types import T
 
 from .exceptions import HostContextException
-from .http import HTTPConnectionHost
+from .http import HTTPHostContext
 from .interface import IHostContext
-from .websocket import WebSocketConnectionHost
+from .websocket import WebSocketHostContext
 
 
 class HostContextFactory(t.Generic[T], ABC):
+    """
+    Factory for creating HostContext types and validating them.
+    """
+
     context_type: t.Type[T]
 
     __slots__ = ("context", "_context_type", "validate_func")
@@ -37,15 +41,20 @@ def create_context_type(self) -> T:
         )
 
 
-class HTTPConnectionContextFactory(HostContextFactory[HTTPConnectionHost]):
-    context_type = HTTPConnectionHost
+class HTTPConnectionContextFactory(HostContextFactory[HTTPHostContext]):
+    context_type = HTTPHostContext
 
     def validate(self) -> None:
+        """
+        Validation is skipped here because HTTPConnection is compatible with websocket and http
+        During websocket connection, we can still get HTTPConnection available,
+        but we can get request instance or response.
+        """
         pass
 
 
-class WebSocketContextFactory(HostContextFactory[WebSocketConnectionHost]):
-    context_type = WebSocketConnectionHost
+class WebSocketContextFactory(HostContextFactory[WebSocketHostContext]):
+    context_type = WebSocketHostContext
 
     def validate(self) -> None:
         if self.context.get_type() != "websocket":

ellar/core/context/host.py

@@ -4,7 +4,7 @@
 from ellar.constants import SCOPE_SERVICE_PROVIDER
 from ellar.types import TReceive, TScope, TSend
 
-from .interface import IHostContext, IHTTPConnectionHost, IWebSocketConnectionHost
+from .interface import IHostContext, IHTTPHostContext, IWebSocketHostContext
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.main import App
@@ -36,11 +36,11 @@ def get_service_provider(self) -> "RequestServiceProvider":
     def _service_provider(self) -> "RequestServiceProvider":
         return self.scope[SCOPE_SERVICE_PROVIDER]  # type:ignore
 
-    def switch_to_http_connection(self) -> IHTTPConnectionHost:
-        return self.get_service_provider().get(IHTTPConnectionHost)  # type: ignore
+    def switch_to_http_connection(self) -> IHTTPHostContext:
+        return self.get_service_provider().get(IHTTPHostContext)  # type: ignore
 
-    def switch_to_websocket(self) -> IWebSocketConnectionHost:
-        return self.get_service_provider().get(IWebSocketConnectionHost)  # type: ignore
+    def switch_to_websocket(self) -> IWebSocketHostContext:
+        return self.get_service_provider().get(IWebSocketHostContext)  # type: ignore
 
     def get_type(self) -> str:
         return str(self.scope["type"])

ellar/core/context/http.py

@@ -8,10 +8,14 @@
 from ellar.types import TReceive, TScope, TSend
 
 from .exceptions import HostContextException
-from .interface import IHTTPConnectionHost
+from .interface import IHTTPHostContext
 
 
-class HTTPConnectionHost(IHTTPConnectionHost):
+class HTTPHostContext(IHTTPHostContext):
+    """
+    Provides a context around HTTP Connection
+    """
+
     __slots__ = (
         "scope",
         "receive",

ellar/core/context/interface.py

@@ -8,11 +8,10 @@
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core import ControllerBase
     from ellar.core.main import App
-    from ellar.core.routing import RouteOperationBase
     from ellar.di.injector import RequestServiceProvider
 
 
-class IHTTPConnectionHost(ABC):
+class IHTTPHostContext(ABC):
     @property
     @abstractmethod
     def has_response(self) -> bool:
@@ -31,7 +30,7 @@ def get_client(self) -> HTTPConnection:
         """Returns HTTPConnection instance"""
 
 
-class IWebSocketConnectionHost(ABC):
+class IWebSocketHostContext(ABC):
     @abstractmethod
     def get_client(self) -> WebSocket:
         """Returns WebSocket instance"""
@@ -43,11 +42,11 @@ def get_service_provider(self) -> "RequestServiceProvider":
         """Gets  RequestServiceProvider instance"""
 
     @abstractmethod
-    def switch_to_http_connection(self) -> IHTTPConnectionHost:
+    def switch_to_http_connection(self) -> IHTTPHostContext:
         """Returns HTTPConnection instance"""
 
     @abstractmethod
-    def switch_to_websocket(self) -> IWebSocketConnectionHost:
+    def switch_to_websocket(self) -> IWebSocketHostContext:
         """Returns WebSocket instance"""
 
     @abstractmethod
@@ -64,10 +63,6 @@ def get_args(self) -> t.Tuple[TScope, TReceive, TSend]:
 
 
 class IExecutionContext(IHostContext, ABC):
-    @abstractmethod
-    def set_operation(self, operation: t.Optional["RouteOperationBase"] = None) -> None:
-        """re-inits operation handler"""
-
     @abstractmethod
     def get_handler(self) -> t.Callable:
         """Gets operation handler"""

ellar/core/context/websocket.py

@@ -2,10 +2,14 @@
 from ellar.core.connection import WebSocket
 from ellar.types import TReceive, TScope, TSend
 
-from .interface import IWebSocketConnectionHost
+from .interface import IWebSocketHostContext
 
 
-class WebSocketConnectionHost(IWebSocketConnectionHost):
+class WebSocketHostContext(IWebSocketHostContext):
+    """
+    Provides a context around websocket session
+    """
+
     __slots__ = (
         "scope",
         "receive",

ellar/core/guard/base.py

@@ -6,7 +6,7 @@
 from starlette.status import HTTP_401_UNAUTHORIZED, HTTP_403_FORBIDDEN
 
 from ellar.core.connection import HTTPConnection
-from ellar.core.context import ExecutionContext
+from ellar.core.context import IExecutionContext
 from ellar.core.exceptions import APIException
 
 
@@ -18,7 +18,7 @@ class GuardCanActivate(ABC, metaclass=ABCMeta):
     detail: str = "Not authenticated"
 
     @abstractmethod
-    async def can_activate(self, context: ExecutionContext) -> bool:
+    async def can_activate(self, context: IExecutionContext) -> bool:
         pass
 
     def raise_exception(self) -> None:
@@ -41,7 +41,7 @@ async def handle_request(self, *, connection: HTTPConnection) -> t.Optional[t.An
     def get_guard_scheme(cls) -> t.Dict:
         pass
 
-    async def can_activate(self, context: ExecutionContext) -> bool:
+    async def can_activate(self, context: IExecutionContext) -> bool:
         connection = context.switch_to_http_connection().get_client()
         result = await self.handle_request(connection=connection)
         if result:

ellar/core/main.py

@@ -5,12 +5,7 @@
 
 from ellar.constants import LOG_LEVELS
 from ellar.core.conf import Config
-from ellar.core.context import (
-    ExecutionContext,
-    HostContext,
-    IExecutionContext,
-    IHostContext,
-)
+from ellar.core.context import IExecutionContext, IHostContext
 from ellar.core.datastructures import State, URLPath
 from ellar.core.events import EventHandler, RouterEventManager
 from ellar.core.exceptions.interfaces import (
@@ -32,7 +27,7 @@
 from ellar.core.templating import AppTemplating, Environment
 from ellar.core.versioning import VERSIONING, BaseAPIVersioning
 from ellar.di.injector import EllarInjector
-from ellar.di.providers import ModuleProvider
+from ellar.di.providers import ServiceUnavailableProvider
 from ellar.logger import logger
 from ellar.services.reflector import Reflector
 from ellar.types import ASGIApp, T, TReceive, TScope, TSend
@@ -269,21 +264,18 @@ def _run_module_application_ready(
             module_ref.run_application_ready(self)
 
     def _finalize_app_initialization(self) -> None:
+
         self.injector.container.register_instance(self)
         self.injector.container.register_instance(Reflector())
         self.injector.container.register_instance(self.config, Config)
         self.injector.container.register_instance(self.jinja_environment, Environment)
         self.injector.container.register_scoped(
             IHostContext,
-            ModuleProvider(
-                HostContext, scope={"type": "invalid"}, receive=None, send=None
-            ),
+            ServiceUnavailableProvider("Service Unavailable at the current context."),
         )
         self.injector.container.register_scoped(
             IExecutionContext,
-            ModuleProvider(
-                ExecutionContext, scope={"type": "invalid"}, receive=None, send=None
-            ),
+            ServiceUnavailableProvider("Service Unavailable at the current context."),
         )
         self._run_module_application_ready()