Feat LazyModule Import: Added support to lazy load ellar modules

eadwinCode · eadwinCode · commit c7aab2858c1e · 2023-12-07T13:04:13.000+01:00
diff --git a/ellar/app/factory.py b/ellar/app/factory.py
@@ -6,8 +6,7 @@
 from ellar.common import EllarTyper
 from ellar.common.constants import MODULE_METADATA, MODULE_WATERMARK
 from ellar.common.models import GuardCanActivate
-from ellar.core.conf import Config
-from ellar.core.modules import DynamicModule, ModuleBase, ModuleSetup
+from ellar.core import Config, DynamicModule, LazyModuleImport, ModuleBase, ModuleSetup
 from ellar.di import EllarInjector, ProviderConfig
 from ellar.reflect import reflect
 from starlette.routing import Host, Mount
@@ -48,6 +47,9 @@ def read_all_module(cls, module_config: ModuleSetup) -> t.Dict[t.Type, ModuleSet
         )
         module_dependency = OrderedDict()
         for module in modules:
+            if isinstance(module, LazyModuleImport):
+                module = module.get_module(module_config.module.__name__)
+
             if isinstance(module, DynamicModule):
                 module.apply_configuration()
                 module_config = ModuleSetup(module.module)
diff --git a/ellar/app/lifespan.py b/ellar/app/lifespan.py
@@ -1,9 +1,9 @@
 import typing as t
+from contextlib import asynccontextmanager
 
 from anyio import create_task_group
 from ellar.common import IApplicationShutdown, IApplicationStartup
 from ellar.common.logger import logger
-from ellar.reflect import asynccontextmanager
 
 if t.TYPE_CHECKING:
     from ellar.app import App
diff --git a/ellar/auth/policy/base.py b/ellar/auth/policy/base.py
@@ -40,7 +40,7 @@ def __or__(
 
     @t.no_type_check
     def __invert__(
-        cls: t.Union["BasePolicyHandler", t.Type["BasePolicyHandler"]]
+        cls: t.Union["BasePolicyHandler", t.Type["BasePolicyHandler"]],
     ) -> "BasePolicyHandler":
         return _NOTPolicy(cls)
 
diff --git a/ellar/common/datastructures.py b/ellar/common/datastructures.py
@@ -25,7 +25,7 @@
 from starlette.datastructures import (
     URLPath,
 )
-from typing_extensions import Annotated, Doc  # type: ignore[attr-defined]
+from typing_extensions import Annotated, Doc
 
 __all__ = [
     "URL",
diff --git a/ellar/common/decorators/exception.py b/ellar/common/decorators/exception.py
@@ -19,7 +19,7 @@ def _add_exception_handler(
 
 
 def exception_handler(
-    exc_class_or_status_code: t.Union[int, t.Type[Exception]]
+    exc_class_or_status_code: t.Union[int, t.Type[Exception]],
 ) -> t.Callable:
     """
     ========= MODULE DECORATOR ==============
diff --git a/ellar/common/decorators/guards.py b/ellar/common/decorators/guards.py
@@ -9,7 +9,7 @@
 
 
 def UseGuards(
-    *_guards: t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"]
+    *_guards: t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"],
 ) -> t.Callable:
     """
     =========CONTROLLER AND ROUTE FUNCTION DECORATOR ==============
diff --git a/ellar/common/decorators/interceptor.py b/ellar/common/decorators/interceptor.py
@@ -9,7 +9,7 @@
 
 
 def UseInterceptors(
-    *args: t.Union[t.Type["EllarInterceptor"], "EllarInterceptor"]
+    *args: t.Union[t.Type["EllarInterceptor"], "EllarInterceptor"],
 ) -> t.Callable:
     """
     =========CONTROLLER AND FUNCTION DECORATOR ==============
diff --git a/ellar/common/params/decorators/inject.py b/ellar/common/params/decorators/inject.py
@@ -47,7 +47,7 @@ def add_default_resolver(
 
 
 def get_default_resolver(
-    type_identifier: t.Union[t.Type, str]
+    type_identifier: t.Union[t.Type, str],
 ) -> t.Optional[t.Type[SystemParameterResolver]]:
     return _DEFAULT_RESOLVERS.get(type_identifier)
 
diff --git a/ellar/common/params/resolvers/parameter.py b/ellar/common/params/resolvers/parameter.py
@@ -273,7 +273,7 @@ async def process_and_validate(
             results: t.List[t.Union[bytes, str]] = []
 
             async def process_fn(
-                fn: t.Callable[[], t.Coroutine[t.Any, t.Any, t.Any]]
+                fn: t.Callable[[], t.Coroutine[t.Any, t.Any, t.Any]],
             ) -> None:
                 result = await fn()
                 results.append(result)
diff --git a/ellar/core/__init__.py b/ellar/core/__init__.py
@@ -4,7 +4,7 @@
 from .connection import HTTPConnection, Request, WebSocket
 from .execution_context import ExecutionContext, HostContext
 from .guards import GuardConsumer
-from .modules import DynamicModule, ModuleBase, ModuleSetup
+from .modules import DynamicModule, LazyModuleImport, ModuleBase, ModuleSetup
 from .services import Reflector, reflector
 
 __all__ = [
@@ -21,6 +21,7 @@
     "Reflector",
     "reflector",
     "GuardConsumer",
+    "LazyModuleImport",
 ]
 
 
diff --git a/ellar/core/modules/__init__.py b/ellar/core/modules/__init__.py
@@ -1,5 +1,5 @@
 from .base import ModuleBase, ModuleBaseMeta
-from .config import DynamicModule, ModuleSetup
+from .config import DynamicModule, LazyModuleImport, ModuleSetup
 from .ref import ModulePlainRef, ModuleRefBase, ModuleTemplateRef
 
 __all__ = [
@@ -10,4 +10,5 @@
     "ModuleSetup",
     "DynamicModule",
     "ModuleBaseMeta",
+    "LazyModuleImport",
 ]
diff --git a/ellar/core/modules/config.py b/ellar/core/modules/config.py
@@ -2,7 +2,9 @@
 import typing as t
 
 from ellar.common.constants import MODULE_METADATA, MODULE_WATERMARK
+from ellar.common.exceptions import ImproperConfiguration
 from ellar.common.models import ControllerBase
+from ellar.common.utils.importer import import_from_string
 from ellar.core.conf import Config
 from ellar.di import MODULE_REF_TYPES, Container, EllarInjector
 from ellar.reflect import reflect
@@ -36,7 +38,7 @@ class DynamicModule:
 
     def __post_init__(self) -> None:
         if not reflect.get_metadata(MODULE_WATERMARK, self.module):
-            raise Exception(f"{self.module.__name__} is not a valid Module")
+            raise ImproperConfiguration(f"{self.module.__name__} is not a valid Module")
 
     def apply_configuration(self) -> None:
         if self._is_configured:
@@ -100,7 +102,7 @@ def module_a_configuration_factory(module: Type[MyModule], config: Config, foo:
 
     def __post_init__(self) -> None:
         if not reflect.get_metadata(MODULE_WATERMARK, self.module):
-            raise Exception(f"{self.module.__name__} is not a valid Module")
+            raise ImproperConfiguration(f"{self.module.__name__} is not a valid Module")
 
         class_names = {cls.__name__ for cls in self.inject}
         if "App" in class_names:
@@ -140,7 +142,7 @@ def configure_with_factory(
 
         res = self.factory(self.module, *services)
         if not isinstance(res, DynamicModule):
-            raise Exception(
+            raise ImproperConfiguration(
                 f"Factory function for {self.module.__name__} module "
                 f"configuration must return `DynamicModule` instance"
             )
@@ -162,3 +164,47 @@ def _get_services(self, injector: EllarInjector) -> t.List:
 
     def __hash__(self) -> int:  # pragma: no cover
         return hash(self.module)
+
+
+class LazyModuleImport:
+    __slots__ = ("module", "setup_method", "setup_method_options")
+
+    def __init__(
+        self, module: str, setup_method: t.Optional[str] = None, **setup_options: t.Any
+    ) -> None:
+        self.module = module
+        self.setup_method = setup_method
+        self.setup_method_options = dict(setup_options)
+
+    @classmethod
+    def validate_module(cls, module: t.Type["ModuleBase"]) -> None:
+        if not reflect.get_metadata(MODULE_WATERMARK, module):
+            raise ImproperConfiguration(f"{module.__name__} is not a valid Module")
+
+    def get_module(
+        self, root_module_name: t.Optional[str] = None
+    ) -> t.Union[t.Type["ModuleBase"], ModuleSetup, DynamicModule]:
+        try:
+            root_module_name = root_module_name or "ApplicationModule"
+            module_cls: t.Type["ModuleBase"] = t.cast(
+                t.Type["ModuleBase"], import_from_string(self.module)
+            )
+        except Exception:
+            raise ImproperConfiguration(
+                f'Unable to import "{self.module}" registered in Module[{root_module_name}]'
+            ) from None
+        self.validate_module(module_cls)
+        if self.setup_method:
+            setup_method = getattr(module_cls, self.setup_method)
+            module_setup = setup_method(**self.setup_method_options)
+            if not isinstance(module_setup, (DynamicModule, ModuleSetup)):
+                raise ImproperConfiguration(
+                    "Lazy Module import with setup attribute must return a "
+                    "DynamicModule/ModuleSetup instance"
+                )
+            return module_setup
+
+        return module_cls
+
+    def __hash__(self) -> int:  # pragma: no cover
+        return hash((self.module, self.setup_method, self.setup_method_options))
diff --git a/ellar/core/routing/helper.py b/ellar/core/routing/helper.py
@@ -37,7 +37,7 @@ def build_route_handler(item: t.Callable) -> t.Optional[RouteOperationBase]:
 
 @t.no_type_check
 def build_route_parameters(
-    items: t.List[t.Union[RouteParameters, WsRouteParameters]]
+    items: t.List[t.Union[RouteParameters, WsRouteParameters]],
 ) -> t.List[RouteOperationBase]:
     results = []
     for item in items:
diff --git a/ellar/di/injector/ellar_injector.py b/ellar/di/injector/ellar_injector.py
@@ -1,8 +1,8 @@
 import typing as t
 from collections import OrderedDict, defaultdict
+from contextlib import asynccontextmanager
 
 from ellar.di.logger import log
-from ellar.reflect import asynccontextmanager
 from injector import Injector, Scope, ScopeDecorator
 
 from ..asgi_args import RequestScopeContext
diff --git a/ellar/di/service_config.py b/ellar/di/service_config.py
@@ -83,7 +83,7 @@ def __call__(self, func_or_class: ConstructorOrClassT) -> ConstructorOrClassT:
 
 
 def injectable(
-    scope: t.Optional[t.Union[t.Type[Scope], ScopeDecorator, t.Type]] = SingletonScope
+    scope: t.Optional[t.Union[t.Type[Scope], ScopeDecorator, t.Type]] = SingletonScope,
 ) -> t.Union[ConstructorOrClassT, t.Callable]:
     """Decorates a callable or Type with inject and Defines Type or callable scope injection scope
 
diff --git a/ellar/pydantic/encoder.py b/ellar/pydantic/encoder.py
@@ -51,7 +51,7 @@
 
 
 def generate_encoders_by_class_tuples(
-    type_encoder_map: t.Dict[t.Any, t.Callable[[t.Any], t.Any]]
+    type_encoder_map: t.Dict[t.Any, t.Callable[[t.Any], t.Any]],
 ) -> t.Dict[t.Callable[[t.Any], t.Any], t.Tuple[t.Any, ...]]:
     encoders_by_class_tuples: t.Dict[
         t.Callable[[t.Any], t.Any], t.Tuple[t.Any, ...]
diff --git a/ellar/pydantic/utils.py b/ellar/pydantic/utils.py
@@ -187,7 +187,7 @@ def field_annotation_is_scalar(annotation: t.Any) -> bool:
 
 
 def field_annotation_is_scalar_sequence(
-    annotation: t.Union[t.Type[t.Any], None]
+    annotation: t.Union[t.Type[t.Any], None],
 ) -> bool:
     origin = get_origin(annotation)
     if origin is t.Union or origin is UnionType:
diff --git a/ellar/reflect/__init__.py b/ellar/reflect/__init__.py
@@ -1,5 +1,4 @@
 from ._reflect import reflect
 from .constants import REFLECT_TYPE
-from .contextmanager_fix import asynccontextmanager
 
-__all__ = ["reflect", "asynccontextmanager", "REFLECT_TYPE"]
+__all__ = ["reflect", "REFLECT_TYPE"]
diff --git a/ellar/reflect/_reflect.py b/ellar/reflect/_reflect.py
@@ -1,17 +1,16 @@
 import logging
 import typing as t
-from contextlib import contextmanager
+from contextlib import asynccontextmanager, contextmanager
 from inspect import ismethod
 from weakref import WeakKeyDictionary
 
 from .constants import REFLECT_TYPE
-from .contextmanager_fix import asynccontextmanager
 
 logger = logging.getLogger("ellar")
 
 
 def _get_actual_target(
-    target: t.Union[t.Type, t.Callable]
+    target: t.Union[t.Type, t.Callable],
 ) -> t.Union[t.Type, t.Callable]:
     try:
         reflect_type = target.__dict__[REFLECT_TYPE]
diff --git a/ellar/reflect/contextmanager_fix.py b/ellar/reflect/contextmanager_fix.py
diff --git a/ellar/socket_io/testing/module.py b/ellar/socket_io/testing/module.py
@@ -1,7 +1,7 @@
 import typing as t
+from contextlib import asynccontextmanager
 
 import socketio
-from ellar.reflect import asynccontextmanager
 from ellar.testing.module import Test, TestingModule
 from ellar.testing.uvicorn_server import EllarUvicornServer
 
diff --git a/tests/test_application/test_application_functions.py b/tests/test_application/test_application_functions.py
@@ -1,5 +1,6 @@
 import os
 import typing as t
+from contextlib import asynccontextmanager
 
 from ellar.app import App, AppFactory
 from ellar.app.services import EllarAppService
@@ -28,7 +29,6 @@
 )
 from ellar.di import EllarInjector
 from ellar.openapi import OpenAPIDocumentModule
-from ellar.reflect import asynccontextmanager
 from ellar.testing import Test, TestClient
 from starlette.responses import JSONResponse, PlainTextResponse, Response
 
diff --git a/tests/test_middleware/test_functional_middleware.py b/tests/test_middleware/test_functional_middleware.py
@@ -1,7 +1,8 @@
+from contextlib import asynccontextmanager
+
 from ellar.common import IHostContext, Inject, Module, ModuleRouter, middleware
 from ellar.core import ModuleBase
 from ellar.core.middleware import FunctionBasedMiddleware
-from ellar.reflect import asynccontextmanager
 from ellar.testing import Test
 from starlette.requests import Request
 from starlette.responses import PlainTextResponse
diff --git a/tests/test_modules/test_module_config.py b/tests/test_modules/test_module_config.py
diff --git a/tests/test_modules/test_module_startup_shutdown.py b/tests/test_modules/test_module_startup_shutdown.py

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@`
`25`	`25`	`from starlette.datastructures import (`
`26`	`26`	`URLPath,`
`27`	`27`	`)`
`28`		`-from typing_extensions import Annotated, Doc # type: ignore[attr-defined]`
	`28`	`+from typing_extensions import Annotated, Doc`
`29`	`29`
`30`	`30`	`__all__ = [`
`31`	`31`	`"URL",`