Merge pull request #146 from python-ellar/lazy_import

Feat: Lazy Object

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,112 @@
+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 ellar.app.main import App
+
+_application_context: ContextVar[
+    t.Optional[t.Union["ApplicationContext", t.Any]]
+] = ContextVar("ellar.app.context")
+
+
+class ApplicationContext:
+    """
+    Provides Necessary Application Properties when running Ellar CLI commands and when serving request.
+
+    """
+
+    __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(empty)
+        if app_context is empty:
+            # If app_context exist
+            _application_context.set(self)
+            if current_config._wrapped is not empty:  # pragma: no cover
+                # 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":
+    app_context = _application_context.get(empty)
+    if app_context is empty:
+        raise RuntimeError("ApplicationContext is not available at this scope.")
+
+    return app_context.app  # type:ignore[union-attr]
+
+
+def _get_injector() -> EllarInjector:
+    app_context = _application_context.get(empty)
+    if app_context is empty:
+        raise RuntimeError("ApplicationContext is not available at this scope.")
+
+    return app_context.injector  # type:ignore[union-attr]
+
+
+def _get_application_config() -> Config:
+    app_context = _application_context.get(empty)
+    if app_context 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,)
+            )
+        return Config(config_module=config_module)
+
+    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

@@ -1,10 +1,11 @@
 import typing as t
 
 from anyio import create_task_group
-from ellar.common import IApplicationShutdown, IApplicationStartup, logger
+from ellar.common import IApplicationShutdown, IApplicationStartup
+from ellar.common.logger import logger
 from ellar.reflect import asynccontextmanager
 
-if t.TYPE_CHECKING:  # pragma: no cover
+if t.TYPE_CHECKING:
     from ellar.app import App
 
 _T = t.TypeVar("_T")
@@ -51,15 +52,17 @@ async def run_all_shutdown_actions(self, app: "App") -> None:
 
     @asynccontextmanager
     async def lifespan(self, app: "App") -> t.AsyncIterator[t.Any]:
-        logger.logger.debug("Executing Modules Startup Handlers")
+        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]
+                logger.info("Application is ready.")
                 yield ctx
         finally:
-            logger.logger.debug("Executing Modules Shutdown Handlers")
+            logger.debug("Executing Modules Shutdown Handlers")
             async with create_task_group() as tg:
                 tg.start_soon(self.run_all_shutdown_actions, app)
+            logger.info("Application shutdown successfully.")

ellar/app/main.py

@@ -2,16 +2,17 @@
 import logging.config
 import typing as t
 
+from ellar.app.context import ApplicationContext
 from ellar.auth.handlers import AuthenticationHandlerType
 from ellar.common import GlobalGuard, IIdentitySchemes
 from ellar.common.compatible import cached_property
 from ellar.common.constants import ELLAR_LOG_FMT_STRING, LOG_LEVELS
 from ellar.common.datastructures import State, URLPath
 from ellar.common.interfaces import IExceptionHandler, IExceptionMiddlewareService
-from ellar.common.logger import logger
 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",
@@ -105,9 +106,6 @@ def _config_logging(self) -> None:
             logging.getLogger("ellar").setLevel(log_level)
             logging.getLogger("ellar.request").setLevel(log_level)
 
-        logger.info(f"APP SETTINGS MODULE: {self.config.config_module}")
-        logger.debug("ELLAR LOGGER CONFIGURED")
-
     def _statics_wrapper(self) -> t.Callable:
         async def _statics_func_wrapper(
             scope: TScope, receive: TReceive, send: TSend
@@ -198,7 +196,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:
@@ -258,9 +256,23 @@ def build_middleware_stack(self) -> ASGIApp:
             app = item(app=app, injector=self.injector)
         return app
 
+    def application_context(self) -> ApplicationContext:
+        """
+        Create an ApplicationContext.
+        Use as a contextmanager block to make `current_app`, `current_injector` and `current_config` point at this application.
+
+        It can be used manually outside ellar cli commands or request,
+        e.g.,
+        with app.application_context():
+            assert current_app is app
+            run_some_actions()
+        """
+        return ApplicationContext.create(app=self)
+
     async def __call__(self, scope: TScope, receive: TReceive, send: TSend) -> None:
-        scope["app"] = self
-        await self.middleware_stack(scope, receive, send)
+        with self.application_context() as ctx:
+            scope["app"] = ctx.app
+            await self.middleware_stack(scope, receive, send)
 
     @property
     def routes(self) -> t.List[BaseRoute]:
@@ -303,9 +315,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 ellar/app/mixin.pyellar/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/datastructures.py

@@ -89,4 +89,4 @@ def __get_validators__(
     def validate(cls: t.Type["UploadFile"], v: t.Any) -> t.Any:
         if not isinstance(v, StarletteUploadFile):
             raise ValueError(f"Expected UploadFile, received: {type(v)}")
-        return v
+        return cls(v.file, size=v.size, filename=v.filename, headers=v.headers)

ellar/common/routing/schema.py

@@ -3,12 +3,10 @@
 from ellar.common.constants import ROUTE_METHODS
 from ellar.common.interfaces import IResponseModel
 from ellar.common.responses.models import EmptyAPIResponseModel, create_response_model
+from ellar.common.routing.websocket import WebSocketExtraHandler
 from ellar.common.serializer import BaseSerializer
 from pydantic import BaseModel, Field, PrivateAttr, root_validator, validator
 
-if t.TYPE_CHECKING:  # pragma: no cover
-    from ellar.common.routing.websocket import WebSocketExtraHandler
-
 
 class TResponseModel:
     @classmethod