Update docs to reflect ExecutionContext refactor

Author: eadwinCode

docs/handling-response/response.md

@@ -1,7 +1,5 @@
 # Handling Responses
 
-## Define a response Schema
-
 **Ellar** allows you to define the schema of your responses both for validation and documentation purposes.
 
 The response schema is defined on the HTTP method decorator and its applied 

docs/overview/controllers.md

@@ -124,7 +124,7 @@ from ellar.core import ControllerBase, Request
 class DogsController(ControllerBase):
     @get()
     def get_all(self):
-        assert isinstance(self.context.switch_to_request(), Request) # True
+        assert isinstance(self.context.switch_to_http_connection().get_request(), Request) # True
         return 'This action returns all dogs'
     ...
 ```
@@ -164,7 +164,7 @@ class DogsController(ControllerBase):
 
     @get()
     def get_all(self):
-        assert isinstance(self.context.switch_to_request(), Request) # True
+        assert isinstance(self.context.switch_to_http_connection().get_request(), Request) # True
         return 'This action returns all dogs'
     ...
 ```
@@ -201,7 +201,7 @@ class DogsController(ControllerBase):
 
     @get()
     async def get_all(self):
-        assert isinstance(self.context.switch_to_request(), Request) # True
+        assert isinstance(self.context.switch_to_http_connection().get_request(), Request) # True
         return 'This action returns all dogs'
     ...
 ```
@@ -292,7 +292,7 @@ class DogsController(ControllerBase):
 
     @get()
     async def get_all(self, query: DogListFilter = Query()):
-        assert isinstance(self.context.switch_to_request(), Request)  # True
+        assert isinstance(self.context.switch_to_http_connection().get_request(), Request)  # True
         return f'This action returns all dogs at limit={query.limit}, offset={query.offset}'
 
 ```

docs/overview/exception_handling.md

@@ -91,7 +91,7 @@ At the root project folder, create a file `custom_exceptions.py`,
 # project_name/custom_exceptions.py
 import typing as t
 from ellar.core.exceptions import IExceptionHandler
-from ellar.core.context import IExecutionContext
+from ellar.core.context import IHostContext
 from starlette.responses import Response
 
 
@@ -103,7 +103,7 @@ class MyCustomExceptionHandler(IExceptionHandler):
     exception_type_or_code = MyCustomException
 
     async def catch(
-        self, ctx: IExecutionContext, exc: MyCustomException
+        self, ctx: IHostContext, exc: MyCustomException
     ) -> t.Union[Response, t.Any]:
         app_config = ctx.get_app().config
         return app_config.DEFAULT_JSON_CLASS(
@@ -123,7 +123,7 @@ Let's create a handler for `MethodNotAllowedException` which, according to the H
 # project_name/apps/custom_exceptions.py
 import typing as t
 from ellar.core.exceptions import IExceptionHandler
-from ellar.core.context import IExecutionContext
+from ellar.core.context import IHostContext
 from ellar.core import render_template
 from starlette.responses import Response
 from starlette.exceptions import HTTPException
@@ -136,7 +136,7 @@ class MyCustomExceptionHandler(IExceptionHandler):
     exception_type_or_code = MyCustomException
 
     async def catch(
-        self, ctx: IExecutionContext, exc: MyCustomException
+        self, ctx: IHostContext, exc: MyCustomException
     ) -> t.Union[Response, t.Any]:
         app_config = ctx.get_app().config
         return app_config.DEFAULT_JSON_CLASS(
@@ -148,10 +148,10 @@ class ExceptionHandlerAction405(IExceptionHandler):
     exception_type_or_code = 405
 
     async def catch(
-        self, ctx: IExecutionContext, exc: HTTPException
+        self, ctx: IHostContext, exc: HTTPException
     ) -> t.Union[Response, t.Any]:
         context_kwargs = {}
-        return render_template('405.html', request=ctx.switch_to_request(), **context_kwargs)
+        return render_template('405.html', request=ctx.switch_to_http_connection().get_request(), **context_kwargs)
 ```
 We have registered a handler for any `HTTP` exception with a `405` status code which we are returning a template `405.html` as a response.
 
@@ -214,15 +214,15 @@ For example:
 # project_name/apps/custom_exceptions.py
 import typing as t
 from ellar.core.exceptions import IExceptionHandler, APIException
-from ellar.core.context import IExecutionContext
+from ellar.core.context import IHostContext
 from starlette.responses import Response
 
 
 class OverrideAPIExceptionHandler(IExceptionHandler):
     exception_type_or_code = APIException
 
     async def catch(
-        self, ctx: IExecutionContext, exc: APIException
+        self, ctx: IHostContext, exc: APIException
     ) -> t.Union[Response, t.Any]:
         app_config = ctx.get_app().config
         return app_config.DEFAULT_JSON_CLASS(

docs/overview/modules.md

@@ -129,12 +129,12 @@ Custom exception handlers can be registered through modules.
 ```python
 from ellar.common import Module, exception_handler
 from ellar.core import  ModuleBase, JSONResponse, Response
-from ellar.core.context import IExecutionContext
+from ellar.core.context import IHostContext
 
 @Module()
 class ModuleExceptionSample(ModuleBase):
     @exception_handler(404)
-    def exception_404_handler(cls, context: IExecutionContext, exc: Exception) -> Response:
+    def exception_404_handler(cls, context: IHostContext, exc: Exception) -> Response:
         return JSONResponse(dict(detail="Resource not found."))
 ```
 `exception_404_handler` will be register to the application at runtime during `ModuleExceptionSample` computation.
@@ -202,29 +202,28 @@ For example:
 ```python
 from ellar.common import Module, middleware
 from ellar.core import ModuleBase
-from ellar.core.context import IExecutionContext
+from ellar.core.context import IHostContext
 from starlette.responses import PlainTextResponse
 
 
 @Module()
 class ModuleMiddlewareSample(ModuleBase):
     @middleware()
-    async def my_middleware_function_1(cls, context: IExecutionContext, call_next):
-        request = context.switch_to_request() # for http response only
+    async def my_middleware_function_1(cls, context: IHostContext, call_next):
+        request = context.switch_to_http_connection().get_request() # for http response only
         request.state.my_middleware_function_1 = True
         await call_next()
 
     @middleware()
-    async def my_middleware_function_2(cls, context: IExecutionContext, call_next):
-        connection = context.switch_to_http_connection() # for websocket response only
-        if connection.scope['type'] == 'websocket':
-            websocket = context.switch_to_websocket()
+    async def my_middleware_function_2(cls, context: IHostContext, call_next):
+        if context.get_type() == 'websocket':
+            websocket = context.switch_to_websocket().get_client()
             websocket.state.my_middleware_function_2 = True
         await call_next()
 
     @middleware()
-    async def my_middleware_function_3(cls, context: IExecutionContext, call_next):
-        connection = context.switch_to_http_connection() # for http response only
+    async def my_middleware_function_3(cls, context: IHostContext, call_next):
+        connection = context.switch_to_http_connection().get_client() # for http response only
         if connection.headers['somekey']:
             # response = context.get_response() -> use the `response` to add extra definitions to things you want to see on
             return PlainTextResponse('Header is not allowed.')

ellar/core/middleware/di.py

@@ -58,8 +58,10 @@ def get_http_connection() -> HTTPConnection:
             http_connection_context = service_provider.get(IHTTPConnectionHost)  # type: ignore
             return http_connection_context.get_client()
 
-        service_provider.register(HTTPConnection, CallableProvider(get_http_connection))
-        service_provider.register(
+        service_provider.update_context(
+            HTTPConnection, CallableProvider(get_http_connection)
+        )
+        service_provider.update_context(
             StarletteHTTPConnection, CallableProvider(get_http_connection)
         )
 
@@ -69,8 +71,10 @@ def get_request_connection() -> Request:
             http_connection_context = service_provider.get(IHTTPConnectionHost)  # type: ignore
             return http_connection_context.get_request()
 
-        service_provider.register(Request, CallableProvider(get_request_connection))
-        service_provider.register(
+        service_provider.update_context(
+            Request, CallableProvider(get_request_connection)
+        )
+        service_provider.update_context(
             StarletteRequest, CallableProvider(get_request_connection)
         )
 
@@ -80,7 +84,7 @@ def get_response() -> Response:
             http_connection_context = service_provider.get(IHTTPConnectionHost)  # type: ignore
             return http_connection_context.get_response()
 
-        service_provider.register(Response, CallableProvider(get_response))
+        service_provider.update_context(Response, CallableProvider(get_response))
 
     @classmethod
     def _register_websocket(cls, service_provider: "RequestServiceProvider") -> None:
@@ -89,8 +93,8 @@ def get_websocket_connection() -> WebSocket:
             return ws_connection_context.get_client()
 
         websocket_context = CallableProvider(get_websocket_connection)
-        service_provider.register(WebSocket, websocket_context)
-        service_provider.register(StarletteWebSocket, websocket_context)
+        service_provider.update_context(WebSocket, websocket_context)
+        service_provider.update_context(StarletteWebSocket, websocket_context)
 
     async def __call__(self, scope: TScope, receive: TReceive, send: TSend) -> None:
         if scope["type"] not in ["http", "websocket"]:  # pragma: no cover
@@ -109,12 +113,12 @@ async def sender(message: TMessage) -> None:
             service_provider.update_context(t.cast(t.Type, IHostContext), host_context)
             service_provider.update_context(t.cast(t.Type, HostContext), host_context)
 
-            service_provider.register_scoped(
+            service_provider.update_context(
                 IHTTPConnectionHost,
                 CallableProvider(HTTPConnectionContextFactory(host_context)),
             )
 
-            service_provider.register_scoped(
+            service_provider.update_context(
                 IWebSocketConnectionHost,
                 CallableProvider(WebSocketContextFactory(host_context)),
             )