Merge branch 'module_configuration' into module_configuration_2

Author: eadwinCode

ellar/common/cache.py

@@ -11,7 +11,7 @@
 from .routing.params import Context, Provide
 
 
-class CacheDecorator:
+class _CacheDecorator:
     __slots__ = (
         "_is_async",
         "_key_prefix",
@@ -136,7 +136,7 @@ def cache(
     ] = None,
 ) -> t.Callable:
     def _wraps(func: t.Callable) -> t.Callable:
-        cache_decorator = CacheDecorator(
+        cache_decorator = _CacheDecorator(
             func,
             timeout,
             key_prefix=key_prefix,

ellar/common/decorators/modules.py

@@ -82,11 +82,11 @@ def Module(
 
     :param static_folder: Module static folder name
 
-    :param modules: List of Module Types - t.Type[MODULEBASE]
+    :param modules: List of Module Types - t.Type[ModuleBase]
 
     :param commands: List of Command Decorated functions and EllarTyper
 
-    :return: t.TYPE[MODULEBASE]
+    :return: t.TYPE[ModuleBase]
     """
     kwargs = AttributeDict(
         name=name,

ellar/constants.py

@@ -93,6 +93,8 @@ def __new__(mcls, name, bases, namespace):
 class MODULE_REF_TYPES(metaclass=_AnnotationToValue):
     PLAIN: str
     TEMPLATE: str
+    DYNAMIC: str
+    APP_DEPENDENT: str
 
 
 class MODULE_METADATA(metaclass=_AnnotationToValue):

ellar/core/__init__.py

@@ -7,7 +7,7 @@
 from .factory import AppFactory
 from .guard import BaseAPIKey, BaseAuthGuard, BaseHttpAuth, GuardCanActivate
 from .main import App
-from .modules import ModuleBase
+from .modules import DynamicModule, IModuleSetup, ModuleBase, ModuleSetup
 from .response import (
     FileResponse,
     HTMLResponse,
@@ -36,6 +36,7 @@
     "ModuleBase",
     "BaseAPIKey",
     "BaseAuthGuard",
+    "IModuleSetup",
     "BaseHttpAuth",
     "GuardCanActivate",
     "Config",
@@ -52,6 +53,8 @@
     "Response",
     "Request",
     "WebSocket",
+    "ModuleSetup",
+    "DynamicModule",
 ]
 
 

ellar/core/factory.py

@@ -3,13 +3,12 @@
 from pathlib import Path
 from uuid import uuid4
 
-from starlette.routing import Host, Mount
+from starlette.routing import BaseRoute, Host, Mount
 
 from ellar.constants import MODULE_METADATA, MODULE_WATERMARK
 from ellar.core import Config
 from ellar.core.main import App
-from ellar.core.modules import ModuleBase
-from ellar.core.modules.ref import create_module_ref_factor
+from ellar.core.modules import DynamicModule, ModuleBase, ModuleSetup
 from ellar.di import EllarInjector, ProviderConfig
 from ellar.reflect import reflect
 
@@ -27,31 +26,38 @@ class AppFactory:
     """
 
     @classmethod
-    def get_all_modules(
-        cls, module: t.Type[t.Union[ModuleBase, t.Any]]
-    ) -> t.List[t.Type[ModuleBase]]:
+    def get_all_modules(cls, module_config: ModuleSetup) -> t.List[ModuleSetup]:
         """
         Gets all registered modules from a particular module in their order of dependencies
-        :param module: Module Type
+        :param module_config: Module Type
         :return: t.List[t.Type[ModuleBase]]
         """
-        module_dependency = [module] + list(cls.read_all_module(module).values())
+        module_dependency = [module_config] + list(
+            cls.read_all_module(module_config).values()
+        )
         return module_dependency
 
     @classmethod
-    def read_all_module(
-        cls, module: t.Type[t.Union[ModuleBase, t.Any]]
-    ) -> t.Dict[t.Type, t.Type[ModuleBase]]:
+    def read_all_module(cls, module_config: ModuleSetup) -> t.Dict[t.Type, ModuleSetup]:
         """
         Retrieves all modules dependencies registered in another module
-        :param module: Module Type
+        :param module_config: Module Type
         :return: t.Dict[t.Type, t.Type[ModuleBase]]
         """
-        modules = reflect.get_metadata(MODULE_METADATA.MODULES, module) or []
+        modules = (
+            reflect.get_metadata(MODULE_METADATA.MODULES, module_config.module) or []
+        )
         module_dependency = OrderedDict()
         for module in modules:
-            module_dependency[module] = module
-            module_dependency.update(cls.read_all_module(module))
+            if isinstance(module, DynamicModule):
+                module_config = ModuleSetup(module.module)
+            elif isinstance(module, ModuleSetup):
+                module_config = module
+            else:
+                module_config = ModuleSetup(module)
+
+            module_dependency[module_config.module] = module_config
+            module_dependency.update(cls.read_all_module(module_config))
         return module_dependency
 
     @classmethod
@@ -60,7 +66,7 @@ def _build_modules(
         app_module: t.Type[t.Union[ModuleBase, t.Any]],
         config: Config,
         injector: EllarInjector,
-    ) -> None:
+    ) -> t.List[BaseRoute]:
         """
         builds application module and registers them to EllarInjector
         :param app_module: Root App Module
@@ -72,18 +78,37 @@ def _build_modules(
             MODULE_WATERMARK, app_module
         ), "Only Module is allowed"
 
-        module_dependency = cls.get_all_modules(app_module)
-        for module in reversed(module_dependency):
-            if injector.get_module(module):  # pragma: no cover
+        app_module_config = ModuleSetup(app_module)
+        module_dependency = cls.get_all_modules(app_module_config)
+        routes = []
+
+        for module_config in reversed(module_dependency):
+            if injector.get_module(module_config.module):  # pragma: no cover
                 continue
 
-            module_ref = create_module_ref_factor(
-                module,
-                container=injector.container,
-                config=config,
+            module_ref = module_config.get_module_ref(
+                container=injector.container, config=config
             )
+
+            if not isinstance(module_ref, ModuleSetup):
+                module_ref.run_module_register_services()
+                routes.extend(module_ref.routes)
+
             injector.add_module(module_ref)
 
+        for module_config in injector.get_dynamic_modules():
+            if injector.get_module(module_config.module):  # pragma: no cover
+                continue
+
+            module_ref = module_config.configure_with_factory(
+                config, injector.container
+            )
+            module_ref.run_module_register_services()
+
+            injector.add_module(module_ref)
+            routes.extend(module_ref.routes)
+        return routes
+
     @classmethod
     def _create_app(
         cls,
@@ -100,20 +125,42 @@ def _create_app(
         injector.container.register_instance(config, concrete_type=Config)
         CoreServiceRegistration(injector, config).register_all()
 
-        cls._build_modules(app_module=module, injector=injector, config=config)
+        routes = cls._build_modules(app_module=module, injector=injector, config=config)
 
         shutdown_event = config.ON_REQUEST_STARTUP
         startup_event = config.ON_REQUEST_SHUTDOWN
 
         app = App(
             config=config,
             injector=injector,
+            routes=routes,
             on_shutdown_event_handlers=shutdown_event if shutdown_event else None,
             on_startup_event_handlers=startup_event if startup_event else None,
             lifespan=config.DEFAULT_LIFESPAN_HANDLER,
             global_guards=global_guards,
         )
 
+        routes = []
+        module_changed = False
+
+        for module_config in injector.get_app_dependent_modules():
+            if injector.get_module(module_config.module):  # pragma: no cover
+                continue
+
+            module_ref = module_config.configure_with_factory(
+                config, injector.container
+            )
+            module_ref.run_module_register_services()
+
+            injector.add_module(module_ref)
+            routes.extend(module_ref.routes)
+            module_changed = True
+
+        if module_changed:
+            app.router.extend(routes)
+            app.reload_static_app()
+            app.rebuild_middleware_stack()
+
         return app
 
     @classmethod

ellar/core/main.py

@@ -20,8 +20,7 @@
     RequestVersioningMiddleware,
     TrustedHostMiddleware,
 )
-from ellar.core.modules import ModuleBase, ModuleTemplateRef
-from ellar.core.modules.ref import create_module_ref_factor
+from ellar.core.modules import DynamicModule, ModuleBase, ModuleSetup, ModuleTemplateRef
 from ellar.core.routing import ApplicationRouter
 from ellar.core.templating import AppTemplating, Environment
 from ellar.core.versioning import VERSIONING, BaseAPIVersioning
@@ -35,6 +34,7 @@ def __init__(
         self,
         config: Config,
         injector: EllarInjector,
+        routes: t.List[BaseRoute],
         on_startup_event_handlers: t.Optional[t.Sequence[EventHandler]] = None,
         on_shutdown_event_handlers: t.Optional[t.Sequence[EventHandler]] = None,
         lifespan: t.Optional[t.Callable[["App"], t.AsyncContextManager]] = None,
@@ -77,7 +77,7 @@ def __init__(
             lifespan or self.config.DEFAULT_LIFESPAN_HANDLER
         )
         self.router = ApplicationRouter(
-            routes=self._get_module_routes(),
+            routes=self._get_module_routes(routes),
             redirect_slashes=self.config.REDIRECT_SLASHES,
             on_startup=[self.on_startup.async_run]
             if self.config.DEFAULT_LIFESPAN_HANDLER is None
@@ -110,8 +110,8 @@ async def _statics_func_wrapper(
 
         return _statics_func_wrapper
 
-    def _get_module_routes(self) -> t.List[BaseRoute]:
-        _routes: t.List[BaseRoute] = []
+    def _get_module_routes(self, routes: t.List[BaseRoute]) -> t.List[BaseRoute]:
+        _routes: t.List[BaseRoute] = list(routes)
         if self.has_static_files:
             self._static_app = self.create_static_app()
             _routes.append(
@@ -122,32 +122,41 @@ def _get_module_routes(self) -> t.List[BaseRoute]:
                 )
             )
 
-        for _, module_ref in self._injector.get_modules().items():
-            module_ref.run_module_register_services()
-            _routes.extend(module_ref.routes)
+        # for _, module_ref in self._injector.get_modules().items():
+        #     _routes.extend(module_ref.routes)
+        #     module_ref.run_module_register_services()
 
         return _routes
 
     def install_module(
         self,
-        module: t.Union[t.Type[T], t.Type[ModuleBase]],
+        module: t.Union[t.Type[T], t.Type[ModuleBase], DynamicModule],
         **init_kwargs: t.Any,
     ) -> t.Union[T, ModuleBase]:
-        module_ref = self.injector.get_module(module)
+        if isinstance(module, DynamicModule):
+            module_config = ModuleSetup(module.module, init_kwargs=init_kwargs)
+        else:
+            module_config = ModuleSetup(module, init_kwargs=init_kwargs)
+
+        module_ref = self.injector.get_module(module_config.module)
         if module_ref:
             return module_ref.get_module_instance()
 
-        module_ref = create_module_ref_factor(
-            module, container=self.injector.container, config=self.config, **init_kwargs
+        module_ref = module_config.get_module_ref(  # type: ignore
+            config=self.config,
+            container=self.injector.container,
         )
+        if not module_ref:
+            raise Exception(f"Invalid Module Configuration for {module_config.module}")
+
         self.injector.add_module(module_ref)
-        self.rebuild_middleware_stack()
 
+        module_ref.run_module_register_services()
         if isinstance(module_ref, ModuleTemplateRef):
-            module_ref.run_module_register_services()
             self.router.extend(module_ref.routes)
             self.reload_static_app()
-            module_ref.run_application_ready(self)
+
+        self.rebuild_middleware_stack()
 
         return t.cast(T, module_ref.get_module_instance())
 
@@ -252,17 +261,10 @@ def enable_versioning(
             **init_kwargs,
         )
 
-    def _run_module_application_ready(
-        self,
-    ) -> None:
-        for _, module_ref in self.injector.get_templating_modules().items():
-            module_ref.run_application_ready(self)
-
     def _finalize_app_initialization(self) -> None:
         self.injector.container.register_instance(self)
         self.injector.container.register_instance(self.config, Config)
         self.injector.container.register_instance(self.jinja_environment, Environment)
-        self._run_module_application_ready()
 
     def add_exception_handler(
         self,

ellar/core/modules/__init__.py

@@ -1,4 +1,13 @@
 from .base import ModuleBase
+from .config import DynamicModule, IModuleSetup, ModuleSetup
 from .ref import ModulePlainRef, ModuleRefBase, ModuleTemplateRef
 
-__all__ = ["ModuleBase", "ModulePlainRef", "ModuleTemplateRef", "ModuleRefBase"]
+__all__ = [
+    "ModuleBase",
+    "ModulePlainRef",
+    "ModuleTemplateRef",
+    "ModuleRefBase",
+    "IModuleSetup",
+    "ModuleSetup",
+    "DynamicModule",
+]

ellar/core/modules/base.py

@@ -7,9 +7,6 @@
 from ellar.core.modules.builder import ModuleBaseBuilder
 from ellar.di.injector import Container
 
-if t.TYPE_CHECKING:  # pragma: no cover
-    from ellar.core import App
-
 
 class ModuleBaseMeta(type):
     __MODULE_FIELDS__: t.Dict = {}
@@ -26,11 +23,10 @@ def __init__(cls, name, bases, namespace) -> None:
 
 class ModuleBase(_InjectorModule, metaclass=ModuleBaseMeta):
     @classmethod
-    def before_init(cls, config: Config) -> None:
-        """Before Module initialisation"""
-
-    def application_ready(self, app: "App") -> None:
-        """Application Ready"""
+    def before_init(cls, config: Config) -> t.Dict:
+        """Before Module initialisation. Whatever value that is returned here will be passed
+        to the Module constructor during initialisation"""
+        return {}
 
     def register_services(self, container: Container) -> None:
         """Register other services manually"""