feat: Added lazy import and application context that exposes default config, current running injector and current running application

Author: eadwinCode

ellar/app/__init__.py

@@ -1,7 +1,11 @@
+from .context import current_app, current_config, current_injector
 from .factory import AppFactory
 from .main import App
 
 __all__ = [
     "App",
     "AppFactory",
+    "current_config",
+    "current_injector",
+    "current_app",
 ]

ellar/app/context.py

@@ -0,0 +1,108 @@
+import os
+import typing as t
+from contextvars import ContextVar
+from types import TracebackType
+
+from ellar.common.constants import ELLAR_CONFIG_MODULE
+from ellar.common.utils.functional import SimpleLazyObject, empty
+from ellar.core import Config
+from ellar.di import EllarInjector
+
+if t.TYPE_CHECKING:
+    from .main import App
+
+_application_context: ContextVar[
+    t.Optional[t.Union["ApplicationContext", t.Any]]
+] = ContextVar("ellar.app.context")
+_application_context.set(empty)
+
+
+class ApplicationContext:
+    __slots__ = ("_injector", "_config", "_app")
+
+    def __init__(self, config: Config, injector: EllarInjector, app: "App") -> None:
+        assert isinstance(config, Config), "config must instance of Config"
+        assert isinstance(
+            injector, EllarInjector
+        ), "injector must instance of EllarInjector"
+
+        self._injector = injector
+        self._config = config
+        self._app = app
+
+    @property
+    def app(self) -> "App":
+        return self._app
+
+    @property
+    def injector(self) -> EllarInjector:
+        return self._injector
+
+    @property
+    def config(self) -> Config:
+        return self._config
+
+    def __enter__(self) -> "ApplicationContext":
+        app_context = _application_context.get()
+        if app_context is empty:
+            # If app_context exist
+            _application_context.set(self)
+            if current_config._wrapped is not empty:
+                # ensure current_config is in sync with running application context.
+                current_config._wrapped = self.config
+
+            app_context = self
+        return app_context  # type:ignore[return-value]
+
+    def __exit__(
+        self,
+        exc_type: t.Optional[t.Any],
+        exc_value: t.Optional[BaseException],
+        tb: t.Optional[TracebackType],
+    ) -> None:
+        _application_context.set(empty)
+
+        current_app._wrapped = empty  # type:ignore[attr-defined]
+        current_injector._wrapped = empty  # type:ignore[attr-defined]
+        current_config._wrapped = empty
+
+    @classmethod
+    def create(cls, app: "App") -> "ApplicationContext":
+        return cls(app.config, app.injector, app)
+
+
+def _get_current_app() -> "App":
+    if _application_context.get() is empty:
+        raise RuntimeError("App is not available at this scope.")
+
+    app_context = _application_context.get()
+    return app_context.app  # type:ignore[union-attr]
+
+
+def _get_injector() -> EllarInjector:
+    if _application_context.get() is empty:
+        raise RuntimeError("App is not available at this scope.")
+
+    app_context = _application_context.get()
+    return app_context.injector  # type:ignore[union-attr]
+
+
+def _get_application_config() -> Config:
+    if _application_context.get() is empty:
+        config_module = os.environ.get(ELLAR_CONFIG_MODULE)
+        if not config_module:
+            raise RuntimeError(
+                "You are trying to access app config outside app context "
+                "and %s is not specified. This may cause differences in config "
+                "values when the app." % (ELLAR_CONFIG_MODULE,)
+            )
+
+    app_context = _application_context.get()
+    return app_context.config  # type:ignore[union-attr]
+
+
+current_app: "App" = t.cast("App", SimpleLazyObject(func=_get_current_app))
+current_injector: EllarInjector = t.cast(
+    EllarInjector, SimpleLazyObject(func=_get_injector)
+)
+current_config: Config = t.cast(Config, SimpleLazyObject(func=_get_application_config))

ellar/app/factory.py

@@ -130,8 +130,10 @@ def _get_config_kwargs() -> t.Dict:
         assert reflect.get_metadata(MODULE_WATERMARK, module), "Only Module is allowed"
 
         config = Config(app_configured=True, **_get_config_kwargs())
+
         injector = EllarInjector(auto_bind=config.INJECTOR_AUTO_BIND)
         injector.container.register_instance(config, concrete_type=Config)
+
         service = EllarAppService(injector, config)
         service.register_core_services()
 

ellar/app/lifespan.py

@@ -4,6 +4,8 @@
 from ellar.common import IApplicationShutdown, IApplicationStartup, logger
 from ellar.reflect import asynccontextmanager
 
+from .context import ApplicationContext
+
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.app import App
 
@@ -53,13 +55,16 @@ async def run_all_shutdown_actions(self, app: "App") -> None:
     async def lifespan(self, app: "App") -> t.AsyncIterator[t.Any]:
         logger.logger.debug("Executing Modules Startup Handlers")
 
-        async with create_task_group() as tg:
-            tg.start_soon(self.run_all_startup_actions, app)
-
-        try:
-            async with self._lifespan_context(app) as ctx:  # type:ignore[attr-defined]
-                yield ctx
-        finally:
-            logger.logger.debug("Executing Modules Shutdown Handlers")
+        with ApplicationContext.create(app):
             async with create_task_group() as tg:
-                tg.start_soon(self.run_all_shutdown_actions, app)
+                tg.start_soon(self.run_all_startup_actions, app)
+
+            try:
+                async with self._lifespan_context(
+                    app
+                ) as ctx:  # type:ignore[attr-defined]
+                    yield ctx
+            finally:
+                logger.logger.debug("Executing Modules Shutdown Handlers")
+                async with create_task_group() as tg:
+                    tg.start_soon(self.run_all_shutdown_actions, app)

ellar/app/main.py

@@ -12,6 +12,7 @@
 from ellar.common.models import EllarInterceptor, GuardCanActivate
 from ellar.common.templating import Environment
 from ellar.common.types import ASGIApp, T, TReceive, TScope, TSend
+from ellar.core import reflector
 from ellar.core.conf import Config
 from ellar.core.middleware import (
     CORSMiddleware,
@@ -32,15 +33,15 @@
 )
 from ellar.core.routing import ApplicationRouter
 from ellar.core.services import Reflector
-from ellar.core.templating import AppTemplating
 from ellar.core.versioning import BaseAPIVersioning, VersioningSchemes
-from ellar.di.injector import EllarInjector
+from ellar.di import EllarInjector
 from starlette.routing import BaseRoute, Mount
 
 from .lifespan import EllarApplicationLifespan
+from .mixin import AppMixin
 
 
-class App(AppTemplating):
+class App(AppMixin):
     def __init__(
         self,
         config: "Config",
@@ -198,7 +199,7 @@ def has_static_files(self) -> bool:  # type: ignore
         )
 
     @property
-    def config(self) -> "Config":  # type: ignore
+    def config(self) -> "Config":
         return self._config
 
     def build_middleware_stack(self) -> ASGIApp:
@@ -303,9 +304,9 @@ def add_exception_handler(
     def rebuild_middleware_stack(self) -> None:
         self.middleware_stack = self.build_middleware_stack()
 
-    @cached_property
+    @property
     def reflector(self) -> Reflector:
-        return self.injector.get(Reflector)  # type: ignore[no-any-return]
+        return reflector
 
     @cached_property
     def __identity_scheme(self) -> IIdentitySchemes:

ellar/core/templating/app.py renamed to ellar/app/mixin.py

@@ -12,21 +12,21 @@
     ModuleTemplating,
 )
 from ellar.common.types import ASGIApp
+from ellar.core.conf import Config
 from ellar.core.connection import Request
 from ellar.core.staticfiles import StaticFiles
+from ellar.di import EllarInjector
 from jinja2 import Environment as BaseEnvironment
 from starlette.templating import pass_context
 
-if t.TYPE_CHECKING:  # pragma: no cover
-    from ellar.core.conf import Config
-    from ellar.core.main import App
-    from ellar.di import EllarInjector
+if t.TYPE_CHECKING:
+    from .main import App
 
 
-class AppTemplating(JinjaTemplating):
-    config: "Config"
+class AppMixin(JinjaTemplating):
     _static_app: t.Optional[ASGIApp]
-    _injector: "EllarInjector"
+    _injector: EllarInjector
+    _config: Config
     has_static_files: bool
 
     @abstractmethod
@@ -43,12 +43,12 @@ def get_module_loaders(self) -> t.Generator[ModuleTemplating, None, None]:
 
     @property
     def debug(self) -> bool:
-        return self.config.DEBUG
+        return self._config.DEBUG
 
     @debug.setter
     def debug(self, value: bool) -> None:
         del self.__dict__["jinja_environment"]
-        self.config.DEBUG = value
+        self._config.DEBUG = value
         # TODO: Add warning
         self.rebuild_middleware_stack()
 
@@ -70,7 +70,7 @@ def select_jinja_auto_escape(filename: str) -> bool:
             "autoescape": select_jinja_auto_escape,
         }
         jinja_options: t.Dict = t.cast(
-            t.Dict, self.config.JINJA_TEMPLATES_OPTIONS or {}
+            t.Dict, self._config.JINJA_TEMPLATES_OPTIONS or {}
         )
 
         for k, v in options_defaults.items():
@@ -81,12 +81,12 @@ def url_for(context: dict, name: str, **path_params: t.Any) -> URL:
             request = t.cast(Request, context["request"])
             return request.url_for(name, **path_params)
 
-        app: App = t.cast("App", self)
+        app: "App" = t.cast("App", self)
 
         jinja_env = Environment(app, **jinja_options)
         jinja_env.globals.update(
             url_for=url_for,
-            config=self.config,
+            config=self._config,
         )
         jinja_env.policies["json.dumps_function"] = json.dumps
         return jinja_env
@@ -97,7 +97,7 @@ def create_global_jinja_loader(self) -> JinjaLoader:
     def create_static_app(self) -> ASGIApp:
         return StaticFiles(
             directories=self.static_files,  # type: ignore[arg-type]
-            packages=self.config.STATIC_FOLDER_PACKAGES,
+            packages=self._config.STATIC_FOLDER_PACKAGES,
         )
 
     def reload_static_app(self) -> None:
@@ -107,12 +107,12 @@ def reload_static_app(self) -> None:
         self._update_jinja_env_filters(self.jinja_environment)
 
     def _update_jinja_env_filters(self, jinja_environment: BaseEnvironment) -> None:
-        jinja_environment.globals.update(self.config.get(TEMPLATE_GLOBAL_KEY, {}))
-        jinja_environment.filters.update(self.config.get(TEMPLATE_FILTER_KEY, {}))
+        jinja_environment.globals.update(self._config.get(TEMPLATE_GLOBAL_KEY, {}))
+        jinja_environment.filters.update(self._config.get(TEMPLATE_FILTER_KEY, {}))
 
     @cached_property
     def static_files(self) -> t.List[str]:
-        static_directories = t.cast(t.List, self.config.STATIC_DIRECTORIES or [])
+        static_directories = t.cast(t.List, self._config.STATIC_DIRECTORIES or [])
         for module in self.get_module_loaders():
             if module.static_directory:
                 static_directories.append(module.static_directory)

ellar/app/services.py

@@ -12,12 +12,12 @@
     IInterceptorsConsumer,
     IWebSocketContextFactory,
 )
-from ellar.core.context import ExecutionContextFactory, HostContextFactory
-from ellar.core.context.factory import (
+from ellar.core.exceptions.service import ExceptionMiddlewareService
+from ellar.core.execution_context import ExecutionContextFactory, HostContextFactory
+from ellar.core.execution_context.factory import (
     HTTPConnectionContextFactory,
     WebSocketContextFactory,
 )
-from ellar.core.exceptions.service import ExceptionMiddlewareService
 from ellar.core.guards import GuardConsumer
 from ellar.core.interceptors import EllarInterceptorConsumer
 from ellar.core.services import Reflector, reflector

ellar/common/templating/loader.py

@@ -6,7 +6,7 @@
 from .environment import Environment
 
 if t.TYPE_CHECKING:  # pragma: no cover
-    from ellar.core.main import App
+    from ellar.app.main import App
 
 
 class JinjaLoader(BaseLoader):