Added current_connection and refactored current_injector

Author: eadwinCode

ellar/core/__init__.py

@@ -2,8 +2,15 @@
 
 from .conf import Config, ConfigDefaultTypesMixin
 from .connection import HTTPConnection, Request, WebSocket
-from .context import ApplicationContext, config, current_injector
-from .execution_context import ExecutionContext, HostContext
+from .execution_context import (
+    ExecutionContext,
+    HostContext,
+    HttpRequestConnectionContext,
+    config,
+    current_connection,
+    current_injector,
+    with_injector_context,
+)
 from .guards import GuardConsumer
 from .interceptors import EllarInterceptorConsumer
 from .modules import (
@@ -15,6 +22,7 @@
 )
 from .services import Reflector, reflector
 from .shortcuts import host, mount
+from .templating import TemplateRenderingService
 from .versioning import VersioningSchemes
 
 __all__ = [
@@ -38,8 +46,11 @@
     "host",
     "current_injector",
     "config",
-    "ApplicationContext",
     "ForwardRefModule",
+    "TemplateRenderingService",
+    "HttpRequestConnectionContext",
+    "current_connection",
+    "with_injector_context",
 ]
 
 

ellar/core/connection/http.py

@@ -4,12 +4,19 @@
 from .execution import ExecutionContext
 from .factory import ExecutionContextFactory, HostContextFactory
 from .host import HostContext
+from .injector import config, current_injector, with_injector_context
+from .request import HttpRequestConnectionContext, current_connection
 
 __all__ = [
     "ExecutionContext",
     "HostContext",
     "ExecutionContextFactory",
     "HostContextFactory",
+    "current_injector",
+    "config",
+    "HttpRequestConnectionContext",
+    "current_connection",
+    "with_injector_context",
 ]
 
 add_default_resolver(ExecutionContext, ExecutionContextParameter)

ellar/core/connection/websocket.py

@@ -20,7 +20,7 @@
 from .websocket import WebSocketHostContext
 
 if t.TYPE_CHECKING:  # pragma: no cover
-    from ellar.common.routing import RouteOperationBase
+    from ellar.core.routing import RouteOperationBase
 
 
 @injectable()

ellar/core/context.py

@@ -10,7 +10,7 @@
 from ellar.common.compatible import cached_property
 from ellar.common.interfaces import IHostContext
 from ellar.common.types import TReceive, TScope, TSend
-from ellar.core.context import current_injector
+from ellar.core.execution_context import current_injector
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.app.main import App

ellar/core/execution_context/__init__.py

@@ -0,0 +1,61 @@
+import os
+import typing as t
+from contextlib import asynccontextmanager
+from contextvars import ContextVar
+
+from ellar.common.constants import ELLAR_CONFIG_MODULE
+from ellar.common.logging import logger
+from ellar.core.conf import Config
+from ellar.di import EllarInjector
+from ellar.utils.functional import SimpleLazyObject, empty
+
+_injector_context_var: ContextVar[EllarInjector] = ContextVar("ellar.di.EllarInjector")
+_injector_context_var.set(empty)
+
+
+def _get_injector() -> EllarInjector:
+    injector_ctx = _injector_context_var.get()
+    if injector_ctx is empty:
+        raise RuntimeError("ApplicationContext is not available at this scope.")
+    return injector_ctx
+
+
+def _get_application_config() -> Config:
+    injector_ctx = _injector_context_var.get()
+    if injector_ctx is not empty:
+        return t.cast(Config, injector_ctx.get(Config))
+
+    config_module = os.environ.get(ELLAR_CONFIG_MODULE)
+    if not config_module:
+        logger.warning(
+            "You are trying to access app config outside app context "
+            "and %s is not specified. This may cause differences in config "
+            "values with the app" % (ELLAR_CONFIG_MODULE,)
+        )
+
+    return Config(config_module=config_module)
+
+
+config: Config = t.cast(Config, SimpleLazyObject(func=_get_application_config))
+
+current_injector: EllarInjector = t.cast(
+    EllarInjector, SimpleLazyObject(func=_get_injector)
+)
+
+
+def _clear_lazy_objects() -> None:
+    current_injector._wrapped = empty  # type:ignore[attr-defined]
+    config._wrapped = empty
+
+
+@asynccontextmanager
+async def with_injector_context(
+    injector: EllarInjector,
+) -> t.AsyncGenerator[EllarInjector, t.Any]:
+    _clear_lazy_objects()
+    _injector_reset_token = _injector_context_var.set(injector)
+
+    yield injector
+
+    _injector_context_var.reset(_injector_reset_token)
+    _clear_lazy_objects()

ellar/core/execution_context/factory.py

@@ -0,0 +1,64 @@
+import typing as t
+from types import TracebackType
+
+from ellar.common import IHostContext
+from ellar.common.logging import logger
+from ellar.di import (
+    RequestScopeContext,
+    register_request_scope_context,
+    request_context_var,
+)
+from ellar.events import request_started, request_teardown
+from ellar.utils.functional import SimpleLazyObject, empty
+
+
+def _clear_lazy_objects() -> None:
+    current_connection._wrapped = empty  # type:ignore[attr-defined]
+
+
+class HttpRequestConnectionContext(RequestScopeContext):
+    def __init__(self, host_context: IHostContext) -> None:
+        super().__init__()
+        self._reset_token: t.Optional[t.Any] = None
+        self.host_context = host_context
+
+    async def __aenter__(self) -> "HttpRequestConnectionContext":
+        self._reset_token = request_context_var.set(self)
+
+        register_request_scope_context(IHostContext, self.host_context)
+
+        _clear_lazy_objects()
+
+        await request_started.run()
+        return self
+
+    @t.no_type_check
+    async def __aexit__(
+        self,
+        exc_type: t.Optional[t.Any],
+        exc_value: t.Optional[BaseException],
+        tb: t.Optional[TracebackType],
+    ) -> None:
+        try:
+            request_context_var.reset(self._reset_token)
+        except ValueError as vex:
+            logger.exception(vex)
+        finally:
+            _clear_lazy_objects()
+
+        await request_teardown.run()
+
+
+def _get_connection() -> IHostContext:
+    request_context: t.Union[HttpRequestConnectionContext, t.Any] = (
+        request_context_var.get(empty)
+    )
+    if request_context is empty:
+        raise RuntimeError("HTTPHostContext is only available during request.")
+
+    return request_context.host_context
+
+
+current_connection: IHostContext = t.cast(
+    IHostContext, SimpleLazyObject(func=_get_connection)
+)

ellar/core/execution_context/host.py

@@ -7,7 +7,7 @@
 from ellar.di import injectable
 
 if t.TYPE_CHECKING:  # pragma: no cover
-    from ellar.common.routing import RouteOperationBase
+    from ellar.core.routing import RouteOperationBase
 
 
 @injectable