Refactored template rendering function and create a TemplateRenderingService

Author: eadwinCode

ellar/common/decorators/html.py

@@ -7,6 +7,7 @@
     MODULE_DECORATOR_ITEM,
     NOT_SET,
     RESPONSE_OVERRIDE_KEY,
+    TEMPLATE_CONTEXT_PROCESSOR_KEY,
     TEMPLATE_FILTER_KEY,
     TEMPLATE_GLOBAL_KEY,
 )
@@ -146,3 +147,24 @@ def decorator(f: TemplateGlobalCallable) -> TemplateGlobalCallable:
         return f
 
     return decorator
+
+
+def template_context() -> t.Callable[[TemplateGlobalCallable], TemplateGlobalCallable]:
+    """
+    Registers a template context processor function. These functions run before
+    rendering a template. The keys of the returned dict are added as variables
+    available in the template.
+
+    Example::
+
+    @template_context()
+    def add_my_context(cls) -> dict:
+        return dict(extra_item="extra_item", ...)
+    """
+
+    def decorator(f: TemplateGlobalCallable) -> TemplateGlobalCallable:
+        setattr(f, TEMPLATE_CONTEXT_PROCESSOR_KEY, f)
+        setattr(f, MODULE_DECORATOR_ITEM, TEMPLATE_CONTEXT_PROCESSOR_KEY)
+        return f
+
+    return decorator

ellar/common/templating/__init__.py

@@ -4,8 +4,6 @@
 from .loader import JinjaLoader, JinjaLoaderType
 from .model import ModuleTemplating
 from .renderer import (
-    get_template_name,
-    process_view_model,
     render_template,
     render_template_string,
 )
@@ -20,6 +18,4 @@
     "TemplateResponse",
     "render_template",
     "render_template_string",
-    "process_view_model",
-    "get_template_name",
 ]

ellar/common/templating/loader.py

@@ -3,6 +3,7 @@
 from ellar.pydantic import as_pydantic_validator
 from jinja2 import TemplateNotFound
 from jinja2.loaders import BaseLoader
+from uvicorn.importer import import_from_string
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.app.main import App
@@ -56,6 +57,9 @@ def list_templates(self) -> t.List[str]:  # pragma: no cover
 class JinjaLoaderType(BaseLoader):
     @classmethod
     def __validate_input__(cls, v: t.Any, _: t.Any) -> t.Any:
+        if isinstance(v, str):
+            v = import_from_string(v)
+
         if not isinstance(v, BaseLoader):
             raise ValueError(f"Expected {BaseLoader} object, received: {type(v)}")
         return v

ellar/common/templating/renderer.py

@@ -1,86 +1,49 @@
 import typing as t
-from functools import lru_cache
 
-import jinja2
-from ellar.common.templating import Environment
+from ellar.common.interfaces import ITemplateRenderingService
 from starlette.background import BackgroundTask
 from starlette.templating import _TemplateResponse as TemplateResponse
 
-if t.TYPE_CHECKING:  # pragma: no cover
-    from ellar.core.connection import Request
 
-
-@lru_cache(1200)
-def get_template_name(template_name: str) -> str:
-    if not template_name.endswith(".html"):
-        return template_name + ".html"
-    return template_name
-
-
-def process_view_model(view_response: t.Any) -> t.Dict:
-    if isinstance(view_response, dict):
-        return view_response
-    return {"model": view_response}
-
-
-def _get_jinja_and_template_context(
-    template_name: str, request: "Request", **context: t.Any
-) -> t.Tuple["jinja2.Template", t.Dict]:
-    jinja_environment = request.service_provider.get(Environment)
-    jinja_template = jinja_environment.get_template(get_template_name(template_name))
-    template_context = dict(context)
-    template_context.update(request=request)
-    return jinja_template, template_context
-
-
-def render_template_string(
-    template_string: str, request: "Request", **template_context: t.Any
-) -> str:
+def render_template_string(template_string: str, **template_context: t.Any) -> str:
     """Renders a template to string.
-    :param request: Request instance
     :param template_string: Template String
     :param template_context: variables that should be available in the context of the template.
     """
-    try:
-        jinja_template, template_context_ = _get_jinja_and_template_context(
-            template_name=template_string,
-            request=request,
-            **process_view_model(template_context),
-        )
-        return jinja_template.render(template_context_)
-    except jinja2.TemplateNotFound:
-        jinja_environment = request.service_provider.get(Environment)
-        jinja_template = jinja_environment.from_string(template_string)
+    from ellar.core.execution_context import current_injector
 
-        _template_context = dict(template_context)
-        _template_context.update(request=request)
-
-        return jinja_template.render(_template_context)
+    rendering_service: ITemplateRenderingService = current_injector.get(
+        ITemplateRenderingService
+    )
+    return rendering_service.render_template_string(
+        template_string=template_string, **template_context
+    )
 
 
 def render_template(
     template_name: str,
-    request: "Request",
     background: t.Optional[BackgroundTask] = None,
+    headers: t.Union[t.Mapping[str, str], None] = None,
     status_code: int = 200,
     **template_kwargs: t.Any,
 ) -> TemplateResponse:
     """Renders a template from the template folder with the given context.
     :param status_code: Template Response status code
-    :param request: Request instance
     :param template_name: the name of the template to be rendered
+    :param headers: Response Headers
     :param template_kwargs: variables that should be available in the context of the template.
     :param background: any background task to be executed after render.
     :return TemplateResponse
     """
-    jinja_template, template_context = _get_jinja_and_template_context(
-        template_name=template_name,
-        request=request,
-        **process_view_model(template_kwargs),
+    from ellar.core.execution_context import current_injector
+
+    rendering_service: ITemplateRenderingService = current_injector.get(
+        ITemplateRenderingService
     )
-    return TemplateResponse(
-        template=jinja_template,
-        context=template_context,
+    return rendering_service.render_template(
+        template_name=template_name,
+        template_context=template_kwargs,
         background=background,
         status_code=status_code,
+        headers=headers,
     )

ellar/core/templating/__init__.py

@@ -0,0 +1,3 @@
+from .service import TemplateRenderingService
+
+__all__ = ["TemplateRenderingService"]

ellar/core/templating/context_processors.py

@@ -0,0 +1,25 @@
+import typing as t
+
+from ellar.core.connection import Request
+
+
+def request_context(request: Request) -> t.Dict[str, t.Any]:
+    return {"request": request}
+
+
+def user(request: Request) -> t.Dict[str, t.Any]:
+    """
+    Return context variables for current request user. This could be AnonymousIdentity or a real user Identity
+    """
+
+    return {
+        "user": request.user,
+    }
+
+
+def request_state(request: Request) -> t.Dict[str, t.Any]:
+    """Adds request state variable to template context"""
+
+    return {
+        "request_state": request.state,
+    }

ellar/core/templating/service.py

@@ -0,0 +1,91 @@
+import typing as t
+from functools import lru_cache
+
+import jinja2
+from ellar.common import IHostContext
+from ellar.common.interfaces import ITemplateRenderingService
+from ellar.common.templating import TemplateResponse
+from ellar.core import Config
+from ellar.di import injectable, request_scope
+from jinja2 import Environment
+from starlette.background import BackgroundTask
+
+
+@lru_cache(1200)
+def get_template_name(template_name: str) -> str:
+    if not template_name.endswith(".html"):
+        return template_name + ".html"
+    return template_name
+
+
+@injectable(scope=request_scope)
+class TemplateRenderingService(ITemplateRenderingService):
+    def __init__(self, config: Config, context: IHostContext) -> None:
+        self.config = config
+        self.context = context
+        self.jinja_env = self.context.get_service_provider().get(Environment)
+
+    def process_view_model(self, view_response: t.Any) -> t.Dict:
+        if isinstance(view_response, dict):
+            return view_response
+        return {"model": view_response}
+
+    def _compute_template_context(self, template_context: t.Dict) -> t.Dict:
+        request = self.context.switch_to_http_connection().get_request()
+
+        org_context = template_context.copy()
+        for processor in self.config.APP_CONTEXT_PROCESSORS or []:
+            res = processor(request)
+            assert isinstance(
+                res, dict
+            ), f"{processor} is expected to return a dict object"
+            template_context.update(res)
+
+        template_context.update(org_context)
+
+        return template_context
+
+    def _get_jinja_and_template_context(
+        self, template_name: str, **context: t.Any
+    ) -> t.Tuple["jinja2.Template", t.Dict]:
+        jinja_template = self.jinja_env.get_template(get_template_name(template_name))
+        template_context = dict(context)
+        return jinja_template, template_context
+
+    def render_template(
+        self,
+        template_name: str,
+        template_context: t.Dict[str, t.Any],
+        background: t.Optional[BackgroundTask] = None,
+        headers: t.Union[t.Mapping[str, str], None] = None,
+        status_code: int = 200,
+        response_type: t.Type[TemplateResponse] = TemplateResponse,
+    ) -> TemplateResponse:
+        jinja_template, template_context_ = self._get_jinja_and_template_context(
+            template_name=template_name,
+            **self.process_view_model(template_context),
+        )
+        template_context = self._compute_template_context(template_context_)
+        return response_type(
+            template=jinja_template,
+            context=template_context,
+            status_code=status_code,
+            background=background,
+            headers=headers,
+        )
+
+    def render_template_string(
+        self, template_string: str, **template_context: t.Any
+    ) -> str:
+        try:
+            jinja_template, template_context_ = self._get_jinja_and_template_context(
+                template_name=template_string,
+                **self.process_view_model(template_context),
+            )
+        except jinja2.TemplateNotFound:
+            jinja_template = self.jinja_env.from_string(template_string)
+            template_context_ = template_context
+
+        template_context = self._compute_template_context(template_context_)
+
+        return jinja_template.render(template_context)