Merge pull request #159 from python-ellar/stack_build_on_lifespan

App stack build on lifespan

Author: eadwinCode

ellar/__init__.py

@@ -1,3 +1,3 @@
 """ Ellar - Python ASGI web framework for building fast, efficient, and scalable RESTful APIs and server-side applications. """
 
-__version__ = "0.6.0"
+__version__ = "0.6.2"

ellar/app/context.py

@@ -8,11 +8,12 @@
 from ellar.common.utils.functional import SimpleLazyObject, empty
 from ellar.core import Config
 from ellar.di import EllarInjector
+from ellar.events import app_context_started_events, app_context_teardown_events
 
 if t.TYPE_CHECKING:
     from ellar.app.main import App
 
-_application_context: ContextVar[
+app_context_var: ContextVar[
     t.Optional[t.Union["ApplicationContext", t.Any]]
 ] = ContextVar("ellar.app.context")
 
@@ -48,14 +49,15 @@ def config(self) -> Config:
         return self._config
 
     def __enter__(self) -> "ApplicationContext":
-        app_context = _application_context.get(empty)
+        app_context = app_context_var.get(empty)
         if app_context is empty:
             # If app_context exist
-            _application_context.set(self)
+            app_context_var.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
+            app_context_started_events.run()
         return app_context  # type:ignore[return-value]
 
     def __exit__(
@@ -64,7 +66,8 @@ def __exit__(
         exc_value: t.Optional[BaseException],
         tb: t.Optional[TracebackType],
     ) -> None:
-        _application_context.set(empty)
+        app_context_teardown_events.run()
+        app_context_var.set(empty)
 
         current_app._wrapped = empty  # type:ignore[attr-defined]
         current_injector._wrapped = empty  # type:ignore[attr-defined]
@@ -76,23 +79,23 @@ def create(cls, app: "App") -> "ApplicationContext":
 
 
 def _get_current_app() -> "App":
-    app_context = _application_context.get(empty)
+    app_context = app_context_var.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)
+    app_context = app_context_var.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)
+    app_context = app_context_var.get(empty)
     if app_context is empty:
         config_module = os.environ.get(ELLAR_CONFIG_MODULE)
         if not config_module:

ellar/app/factory.py

@@ -42,13 +42,14 @@ def read_all_module(cls, module_config: ModuleSetup) -> t.Dict[t.Type, ModuleSet
         :param module_config: Module Type
         :return: t.Dict[t.Type, t.Type[ModuleBase]]
         """
+        global_module_config = module_config
         modules = (
             reflect.get_metadata(MODULE_METADATA.MODULES, module_config.module) or []
         )
         module_dependency = OrderedDict()
         for module in modules:
             if isinstance(module, LazyModuleImport):
-                module = module.get_module(module_config.module.__name__)
+                module = module.get_module(global_module_config.module.__name__)
 
             if isinstance(module, DynamicModule):
                 module.apply_configuration()
@@ -167,7 +168,7 @@ def _get_config_kwargs() -> t.Dict:
 
         if module_changed:
             app.router.extend(routes)
-            app.rebuild_stack()
+            # app.rebuild_stack()
 
         return app
 

ellar/app/main.py

@@ -81,20 +81,11 @@ def __init__(
                 self.config.DEFAULT_LIFESPAN_HANDLER  # type: ignore[arg-type]
             ).lifespan,
         )
-        if (
-            self.config.STATIC_MOUNT_PATH
-            and self.config.STATIC_MOUNT_PATH not in self.router.routes
-        ):
-            self.router.append(AppStaticFileMount(self))
 
         self._finalize_app_initialization()
-        self.middleware_stack = self.build_middleware_stack()
+        self.middleware_stack: t.Optional[ASGIApp] = None
         self._config_logging()
 
-        self.reload_event_manager += lambda app: self._update_jinja_env_filters(  # type:ignore[misc]
-            self.jinja_environment
-        )
-
     def _config_logging(self) -> None:
         log_level = (
             self.config.LOG_LEVEL.value
@@ -150,8 +141,8 @@ def install_module(
         if isinstance(module_ref, ModuleTemplateRef):
             self.router.extend(module_ref.routes)
 
-        self.rebuild_stack()
-
+        # self.rebuild_stack()
+        self._update_jinja_env_filters(self.jinja_environment)
         return t.cast(T, module_ref.get_module_instance())
 
     def get_guards(self) -> t.List[t.Union[t.Type[GuardCanActivate], GuardCanActivate]]:
@@ -257,6 +248,17 @@ def application_context(self) -> ApplicationContext:
     async def __call__(self, scope: TScope, receive: TReceive, send: TSend) -> None:
         with self.application_context() as ctx:
             scope["app"] = ctx.app
+            if self.middleware_stack is None:
+                self.middleware_stack = self.build_middleware_stack()
+
+                self._update_jinja_env_filters(self.jinja_environment)
+
+                if (
+                    self.config.STATIC_MOUNT_PATH
+                    and self.config.STATIC_MOUNT_PATH not in self.router.routes
+                ):
+                    self.router.append(AppStaticFileMount(self))
+
             await self.middleware_stack(scope, receive, send)
 
     @property
@@ -291,17 +293,17 @@ def add_exception_handler(
         self,
         *exception_handlers: IExceptionHandler,
     ) -> None:
-        _added_any = False
+        # _added_any = False
         for exception_handler in exception_handlers:
             if exception_handler not in self._exception_handlers:
                 self._exception_handlers.append(exception_handler)
-                _added_any = True
-        if _added_any:
-            self.rebuild_stack()
+                # _added_any = True
+        # if _added_any:
+        #     self.rebuild_stack()
 
-    def rebuild_stack(self) -> None:
-        self.middleware_stack = self.build_middleware_stack()
-        self.reload_event_manager.run(self)
+    # def rebuild_stack(self) -> None:
+    #     self.middleware_stack = self.build_middleware_stack()
+    #     self.reload_event_manager.run(self)
 
     @property
     def reflector(self) -> Reflector:

ellar/app/mixin.py

@@ -14,7 +14,6 @@
 from ellar.core.conf import Config
 from ellar.core.connection import Request
 from ellar.di import EllarInjector
-from ellar.events import EventManager
 from jinja2 import Environment as BaseEnvironment
 from starlette.templating import pass_context
 
@@ -26,8 +25,7 @@ class AppMixin(JinjaTemplating):
     _static_app: t.Optional[ASGIApp]
     _injector: EllarInjector
     _config: Config
-    rebuild_stack: t.Callable
-    reload_event_manager = EventManager()
+    # rebuild_stack: t.Callable
 
     def get_module_loaders(self) -> t.Generator[ModuleTemplating, None, None]:
         for loader in self._injector.get_templating_modules().values():
@@ -42,7 +40,7 @@ def debug(self, value: bool) -> None:
         del self.__dict__["jinja_environment"]
         self._config.DEBUG = value
         # TODO: Add warning
-        self.rebuild_stack()
+        # self.rebuild_stack()
 
     @cached_property
     def jinja_environment(self) -> BaseEnvironment:  # type: ignore[override]

ellar/common/decorators/modules.py

@@ -8,6 +8,7 @@
 from ellar.common.exceptions import ImproperConfiguration
 from ellar.common.models import ControllerBase
 from ellar.common.routing import ModuleMount, ModuleRouter
+from ellar.common.utils.importer import get_main_directory_by_stack
 from ellar.di import ProviderConfig, SingletonScope, injectable
 from ellar.reflect import reflect
 from starlette.routing import Host, Mount
@@ -76,6 +77,7 @@ def Module(
 
     :return: t.TYPE[ModuleBase]
     """
+    base_directory = get_main_directory_by_stack(base_directory, stack_level=2)  # type:ignore[arg-type]
     kwargs = AttributeDict(
         name=name,
         controllers=list(controllers),

ellar/common/utils/importer.py

@@ -1,5 +1,8 @@
+import inspect
+import os
 import re
 import typing as t
+from pathlib import Path
 
 _module_import_regex = re.compile("(((\\w+)?(\\.<\\w+>)?(\\.\\w+))+)", re.IGNORECASE)
 
@@ -70,3 +73,49 @@ def get_class_import(klass: t.Union[t.Type, t.Any]) -> str:  # pragma: no cover
     if len(split_result) == 2:
         return f"{split_result[0]}:{split_result[1]}"
     return result
+
+
+def get_main_directory_by_stack(
+    path: str, stack_level: int, from_dir: t.Optional[str] = None
+) -> str:
+    """
+    Gets Directory Based on execution stack level or from a base directory
+
+    example:
+        from pathlib import Path
+
+        directory = get_main_directory_by_stack("__main__", stack_level=1)
+        file_directory = Path(__file__).resolve()
+
+        assert directory == str(file_directory)
+
+        directory = get_main_directory_by_stack("__main__", stack_level=2)
+        assert directory == str(file_directory.parent)
+    """
+    forced_path_to_string = str(path)
+    if forced_path_to_string.startswith("__main__") or forced_path_to_string.startswith(
+        "/__main__"
+    ):
+        __main__, others = forced_path_to_string.replace("/", " ").split("__main__")
+        __parent__ = False
+
+        if "__parent__" in others:
+            __parent__ = True
+
+        if not from_dir:
+            stack = inspect.stack()[stack_level]
+            __main__parent = Path(stack.filename).resolve().parent
+        else:
+            # let's work with a given base directory
+            __main__parent = Path(from_dir).resolve()
+
+        if __parent__:
+            parent_split = others.split("__parent__")
+            for item in parent_split:
+                if item == " ":
+                    __main__parent = __main__parent.parent
+                else:
+                    return os.path.join(__main__parent, item.strip())
+
+        return os.path.join(str(__main__parent), others.strip())
+    return path

ellar/core/modules/config.py

@@ -189,10 +189,10 @@ def get_module(
             module_cls: t.Type["ModuleBase"] = t.cast(
                 t.Type["ModuleBase"], import_from_string(self.module)
             )
-        except Exception:
+        except Exception as ex:
             raise ImproperConfiguration(
-                f'Unable to import "{self.module}" registered in Module[{root_module_name}]'
-            ) from None
+                f'Unable to import "{self.module}" registered in "{root_module_name}"'
+            ) from ex
         self.validate_module(module_cls)
         if self.setup_method:
             setup_method = getattr(module_cls, self.setup_method)

ellar/core/routing/file_mount.py

@@ -1,9 +1,8 @@
-import inspect
 import os.path
 import typing as t
-from pathlib import Path
 
 from ellar.common.types import ASGIApp
+from ellar.common.utils.importer import get_main_directory_by_stack
 from ellar.core.staticfiles import StaticFiles
 from starlette.middleware import Middleware
 from starlette.routing import BaseRoute, Mount
@@ -22,11 +21,7 @@ def __init__(
         middleware: t.Optional[t.Sequence[Middleware]] = None,
         base_directory: t.Optional[str] = None,
     ) -> None:
-        if base_directory == "__parent__":
-            # stacks = inspect.stack()
-            stack = inspect.stack()[1]
-            base_directory = Path(stack.filename).resolve().parent  # type:ignore[assignment]
-
+        base_directory = get_main_directory_by_stack(base_directory, stack_level=2)  # type: ignore[arg-type]
         if base_directory:
             directories = [
                 str(os.path.join(base_directory, directory))
@@ -62,7 +57,6 @@ def __init__(self, app: "App") -> None:
             packages=packages,
         )
         # subscribe to app reload
-        app.reload_event_manager += self._reload_static_files  # type:ignore[misc]
 
     def _get_static_directories(self, app: "App") -> tuple:
         static_directories = t.cast(t.List, app.config.STATIC_DIRECTORIES or [])
@@ -71,8 +65,8 @@ def _get_static_directories(self, app: "App") -> tuple:
                 static_directories.append(module.static_directory)
         return static_directories, app.config.STATIC_FOLDER_PACKAGES
 
-    def _reload_static_files(self, app: "App") -> None:
-        directories, packages = self._get_static_directories(app)
-        self.app = self._combine_app_with_middleware(
-            StaticFiles(directories=directories, packages=packages)
-        )
+    # def _reload_static_files(self, app: "App") -> None:
+    #     directories, packages = self._get_static_directories(app)
+    #     self.app = self._combine_app_with_middleware(
+    #         StaticFiles(directories=directories, packages=packages)
+    #     )

ellar/events/__init__.py

@@ -0,0 +1,11 @@
+from .base import EventHandler, EventManager
+
+app_context_started_events = EventManager()
+app_context_teardown_events = EventManager()
+
+__all__ = [
+    "app_context_started_events",
+    "app_context_teardown_events",
+    "EventHandler",
+    "EventManager",
+]