Merge pull request #230 from python-ellar/module_concept

Ft: Module Routes Execution Context

Author: eadwinCode

.github/workflows/test_full.yml

@@ -32,7 +32,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: 3.8
+          python-version: 3.9
       - name: Install Flit
         run: pip install flit
       - name: Install Dependencies

docs/overview/exception_handling.md

@@ -200,7 +200,7 @@ class ExceptionHandlerAction405(IExceptionHandler):
         self, ctx: IHostContext, exc: HTTPException
     ) -> t.Union[Response, t.Any]:
         context_kwargs = {}
-        return render_template('405.html', request=ctx.switch_to_http_connection().get_request(), **context_kwargs)
+        return render_template('405.html', **context_kwargs)
 ```
 In this code snippet, we've registered a handler for any `HTTP` exception with a `405` status code, and we return a template, `405.html`, as a response. 
 Similarly, you can create an exception handler for the `500` status code that returns an HTML template.

docs/security/rate-limit.md

@@ -103,7 +103,7 @@ from ellar.common import Controller, get
 
 
 @Controller("/limit")
-@Throttle(apply_interceptor=True)
+@Throttle(intercept=True)
 class LimitController:
     def __init__(self, app_service: AppService):
         self.app_service = app_service
@@ -113,15 +113,15 @@ class LimitController:
         return self.app_service.success(use_auth)
 ```
 
-In the above example, by setting `apply_interceptor=True` within **@Throttle**, 
+In the above example, by setting `intercept=True` within **@Throttle**, 
 the `ThrottlerInterceptor` is applied to all routes within the `LimitController`. 
 This feature is particularly useful when `ThrottlerInterceptor` is not globally applied.
 
 Additionally, the **@Throttle** decorator can be used on a route level:
 
 ```python
 @get()
-@Throttle(apply_interceptor=True)
+@Throttle(intercept=True)
 def get_throttled(self, use_auth: bool):
     return self.app_service.success(use_auth)
 ```
@@ -130,7 +130,7 @@ Another application of the **@Throttle** decorator is to override `ttl` and `lim
 
 ```python
 @Controller("/limit")
-@Throttle(apply_interceptor=True, anon={'ttl': 100, 'limit': 30})
+@Throttle(intercept=True, anon={'ttl': 100, 'limit': 30})
 class LimitController:
     def __init__(self, app_service: AppService):
         self.app_service = app_service

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.8.0"
+__version__ = "0.8b"

ellar/app/__init__.py

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

ellar/app/factory.py

@@ -2,7 +2,6 @@
 from pathlib import Path
 
 import click
-from ellar.app.core_module import get_core_module
 from ellar.common import IApplicationReady, Module
 from ellar.common.constants import MODULE_METADATA
 from ellar.common.exceptions import ImproperConfiguration
@@ -15,19 +14,22 @@
     ModuleBase,
     ModuleSetup,
 )
+from ellar.core.execution_context import injector_context
+from ellar.core.module import get_core_module
 from ellar.core.modules import ModuleRefBase, ModuleTemplateRef
 from ellar.di import EllarInjector, ProviderConfig
 from ellar.di.injector.tree_manager import ModuleTreeManager
 from ellar.reflect import reflect
-from ellar.threading.sync_worker import execute_async_context_manager
+from ellar.threading.sync_worker import execute_async_context_manager, execute_coroutine
 from ellar.utils import get_name, get_unique_type
 from starlette.routing import Host, Mount
 
+from ..events.build import build_with_context_event
 from .main import App
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.common import ModuleRouter
-    from ellar.core.routing import EllarMount
+    from ellar.core.routing import EllarControllerMount
 
 
 class AppFactory:
@@ -115,17 +117,23 @@ def _get_config_kwargs() -> t.Dict:
             parent_container=injector.container if injector else None,
             config=config,
         )
-        core_module_ref.initiate_module_build()
+        with execute_async_context_manager(
+            injector_context(core_module_ref.container.injector)
+        ) as context:
+            core_module_ref.initiate_module_build()
 
-        # service = EllarAppService(injector, config)
-        # service.register_core_services()
-
-        with execute_async_context_manager(core_module_ref.context()) as context:
             tree_manager: ModuleTreeManager = core_module_ref.get(ModuleTreeManager)
             cls.read_all_module(core_module_ref, tree_manager)
+
+            # service = EllarAppService(injector, config)
+            # service.register_core_services()
+
             # Build application first level. This will trigger ApplicationModule to be built
             core_module_ref.build_dependencies(step=1)
-            app_module_ref = tree_manager.get_root_module()
+            app_module_ref = tree_manager.get_app_module()
+
+            execute_coroutine(build_with_context_event.run())
+            build_with_context_event.disconnect_all()
 
             app = App(
                 routes=[],
@@ -155,19 +163,21 @@ def _get_config_kwargs() -> t.Dict:
             # app.setup_jinja_environment
             app.setup_jinja_environment()
 
-            for module, data in context.injector.tree_manager.modules.items():
+            for module, data in context.tree_manager.modules.items():
                 data.value.run_module_register_services()
 
                 if issubclass(module, IApplicationReady):
-                    context.injector.get(module).on_ready(app)
+                    context.get(module).on_ready(app)
 
         return app
 
     @classmethod
     def create_app(
         cls,
         controllers: t.Sequence[t.Union[t.Type]] = (),
-        routers: t.Sequence[t.Union["ModuleRouter", "EllarMount", Mount, Host]] = (),
+        routers: t.Sequence[
+            t.Union["ModuleRouter", "EllarControllerMount", Mount, Host, t.Callable]
+        ] = (),
         providers: t.Sequence[t.Union[t.Type, "ProviderConfig"]] = (),
         modules: t.Sequence[t.Type[t.Union[ModuleBase, t.Any]]] = (),
         template_folder: t.Optional[str] = None,