fastlifeweb 0.11.1__py3-none-any.whl → 0.13.0__py3-none-any.whl

fastlife/{templates → components}/Td.jinja

@@ -4,7 +4,7 @@
   class_: Annotated[
     str | None,
     "css class for the node, defaults to "
-    ":attr:`fastlife.templating.renderer.constants.Constants.TD_CLASS`"
+    ":attr:`fastlife.templates.constants.Constants.TD_CLASS`"
   ] = None,
 #}
 <td

fastlife/{templates → components}/Th.jinja

@@ -4,7 +4,7 @@
   class_: Annotated[
     str | None,
     "css class for the node, defaults to "
-    ":attr:`fastlife.templating.renderer.constants.Constants.TH_CLASS`."
+    ":attr:`fastlife.templates.constants.Constants.TH_CLASS`."
   ] = None,
 #}
 <th

fastlife/{templates → components}/pydantic_form/Boolean.jinja

@@ -1,5 +1,5 @@
 {# doc Render a checkbox and a label for boolean field. #}
-{# def widget: Annotated[fastlife.templating.renderer.widgets.boolean.BooleanWidget, "widget to display."] #}
+{# def widget: Annotated[fastlife.adapters.jinjax.widgets.boolean.BooleanWidget, "widget to display."] #}
 <pydantic_form.Widget :widget="widget">
   <div class="pt-4">
     <div class="flex items-center">

fastlife/{templates → components}/pydantic_form/Checklist.jinja

@@ -1,5 +1,5 @@
 {# doc Render a list of checkbox and a label for Literal and enum fields #}
-{# def widget: Annotated[fastlife.templating.renderer.widgets.checklist.ChecklistWidget, "widget to display."] #}
+{# def widget: Annotated[fastlife.adapters.jinjax.widgets.checklist.ChecklistWidget, "widget to display."] #}
 <pydantic_form.Widget :widget="widget">
   <div class="pt-4">
     <Details>

fastlife/{templates → components}/pydantic_form/Dropdown.jinja

@@ -1,5 +1,5 @@
 {# doc Render a Select with options #}
-{# def widget: Annotated[fastlife.templating.renderer.widgets.dropdown.DropDownWidget, "widget to display."] #}
+{# def widget: Annotated[fastlife.adapters.jinjax.widgets.dropdown.DropDownWidget, "widget to display."] #}
 
 <pydantic_form.Widget :widget="widget">
   <div class="pt-4">

fastlife/{templates → components}/pydantic_form/Hidden.jinja

@@ -1,3 +1,3 @@
 {# doc Render a hidden input field for a field. #}
-{# def widget: Annotated[fastlife.templating.renderer.widgets.hidden.HiddenWidget, "widget to display."] #}
+{# def widget: Annotated[fastlife.adapters.jinjax.widgets.hidden.HiddenWidget, "widget to display."] #}
 <Hidden :name="widget.name" :value="widget.value" :id="widget.id" />

fastlife/{templates → components}/pydantic_form/Model.jinja

@@ -1,8 +1,8 @@
 {# doc Widget for pydantic BaseModel subclasses. #}
 {# def
-    widget: Annotated[fastlife.templating.renderer.widgets.model.ModelWidget, "widget to display."],
+    widget: Annotated[fastlife.adapters.jinjax.widgets.model.ModelWidget, "widget to display."],
     children_widget : Annotated[
-        Sequence[fastlife.templating.renderer.widgets.base.Widget],
+        Sequence[fastlife.adapters.jinjax.widgets.base.Widget],
         "child widgets for every fields of the model."
     ],
 #}

fastlife/{templates → components}/pydantic_form/Sequence.jinja

@@ -1,11 +1,11 @@
 {# doc Widget for pydantic BaseModel subclasses. #}
 {# def
-    widget: Annotated[fastlife.templating.renderer.widgets.sequence.SequenceWidget, "widget to display."],
+    widget: Annotated[fastlife.adapters.jinjax.widgets.sequence.SequenceWidget, "widget to display."],
     children_widgets : Annotated[
-        Sequence[fastlife.templating.renderer.widgets.base.Widget],
+        Sequence[fastlife.adapters.jinjax.widgets.base.Widget],
         "child widgets for every fields of the model."
     ],
-    type: Annotated[fastlife.templating.renderer.widgets.base.TypeWrapper, "child type wrapped."]
+    type: Annotated[fastlife.adapters.jinjax.widgets.base.TypeWrapper, "child type wrapped."]
 #}
 
 <pydantic_form.Widget :widget="widget">

fastlife/{templates → components}/pydantic_form/Text.jinja

@@ -1,4 +1,4 @@
-{# def widget: Annotated[fastlife.templating.renderer.widgets.text.TextWidget, "widget to display."] #}
+{# def widget: Annotated[fastlife.adapters.jinjax.widgets.text.TextWidget, "widget to display."] #}
 
 <pydantic_form.Widget :widget="widget">
   <div class="pt-4">

fastlife/{templates → components}/pydantic_form/Textarea.jinja

@@ -3,7 +3,7 @@ Render textarea widget for field of type text of event sequence.
 
 ::
 
-    from fastlife.templating.renderer.widgets.text import TextareaWidget
+    from fastlife.adapters.jinjax.widgets.text import TextareaWidget
     from pydantic import BaseModel, Field, field_validator
 
     class TagsForm(BaseModel):
@@ -19,14 +19,20 @@ Render textarea widget for field of type text of event sequence.
             return s.split() if s else []
 
  #}
-{# def widget: Annotated[fastlife.templating.renderer.widgets.text.TextareaWidget, "widget to display."] #}
+{# def widget: Annotated[fastlife.adapters.jinjax.widgets.text.TextareaWidget, "widget to display."] #}
 
 <pydantic_form.Widget :widget="widget">
   <div class="pt-4">
     <Label :for="widget.id">{{widget.title}}</Label>
     <pydantic_form.Error :text="widget.error" />
-    <Textarea :name="widget.name" :id="widget.id" :aria-label="widget.aria_label">{% for v in widget.value%}{{v}}
-{% endfor %}</Textarea>
+    <Textarea :name="widget.name" :id="widget.id" :aria-label="widget.aria_label">
+        {%- if v is string -%}
+        {{- v -}}}
+        {%- else -%}
+        {%- for v in widget.value %}{{v}}
+{% endfor -%}
+        {% endif %}
+    </Textarea>
     <pydantic_form.Hint :text="widget.hint" />
   </div>
 </pydantic_form.Widget>

fastlife/{templates → components}/pydantic_form/Union.jinja

@@ -1,9 +1,9 @@
 {# doc display widget for union type field #}
 {# def
-widget: Annotated[fastlife.templating.renderer.widgets.base.Widget, "widget to display."],
-child: Annotated[fastlife.templating.renderer.widgets.base.Widget, "current widget if any"],
-types: Annotated[Sequence[fastlife.templating.renderer.widgets.base.TypeWrapper], "Child types to choose"],
-parent_type: Annotated[fastlife.templating.renderer.widgets.base.TypeWrapper, "parent type"]
+widget: Annotated[fastlife.adapters.jinjax.widgets.base.Widget, "widget to display."],
+child: Annotated[fastlife.adapters.jinjax.widgets.base.Widget, "current widget if any"],
+types: Annotated[Sequence[fastlife.adapters.jinjax.widgets.base.TypeWrapper], "Child types to choose"],
+parent_type: Annotated[fastlife.adapters.jinjax.widgets.base.TypeWrapper, "parent type"]
 #}
 
 <pydantic_form.Widget :widget="widget">

fastlife/{templates → components}/pydantic_form/Widget.jinja

@@ -1,6 +1,6 @@
 {# doc Base component for widget #}
 {# def
-widget: Annotated[fastlife.templating.renderer.widgets.base.Widget, "widget to display."],
+widget: Annotated[fastlife.adapters.jinjax.widgets.base.Widget, "widget to display."],
 #}
 {% set container_id = widget.id + "-container" %}
 <div id="{{container_id}}">

fastlife/config/__init__.py

@@ -2,11 +2,16 @@
 
 from .configurator import Configurator, configure
 from .registry import AppRegistry, Registry
+from .resources import resource, resource_view
 from .settings import Settings
+from .views import view_config
 
 __all__ = [
     "Configurator",
     "configure",
+    "view_config",
+    "resource",
+    "resource_view",
     "Registry",
     "AppRegistry",
     "Settings",

fastlife/config/configurator.py

@@ -14,32 +14,67 @@ phase.
 import importlib
 import inspect
 import logging
+from collections.abc import Mapping
 from enum import Enum
 from pathlib import Path
 from types import ModuleType
-from typing import TYPE_CHECKING, Any, Callable, List, Optional, Self, Type, Union
+from typing import TYPE_CHECKING, Annotated, Any, Callable, Self, Tuple, Type, cast
 
 import venusian
 from fastapi import Depends, FastAPI
 from fastapi import Request as BaseRequest
+from fastapi import Response
 from fastapi.params import Depends as DependsType
 from fastapi.staticfiles import StaticFiles
+from fastapi.types import IncEx
+from pydantic import BaseModel, Field
 
 from fastlife.middlewares.base import AbstractMiddleware
 from fastlife.request.request import Request
 from fastlife.routing.route import Route
+from fastlife.routing.router import Router
 from fastlife.security.csrf import check_csrf
 from fastlife.shared_utils.resolver import resolve
 
 from .settings import Settings
 
 if TYPE_CHECKING:
-    from .registry import AppRegistry  # coverage: ignore
+    from fastlife.services.templates import (
+        AbstractTemplateRendererFactory,  # coverage: ignore; coverage: ignore
+    )
+
+    from .registry import AppRegistry, LocaleNegociator  # coverage: ignore
 
 log = logging.getLogger(__name__)
 VENUSIAN_CATEGORY = "fastlife"
 
 
+class ConfigurationError(Exception):
+    """
+    Error raised during configuration, to avoid errors at runtime.
+    """
+
+
+class ExternalDocs(BaseModel):
+    """OpenAPI externalDocs object."""
+
+    description: str
+    """link's description."""
+    url: str
+    """link's URL."""
+
+
+class OpenApiTag(BaseModel):
+    """OpenAPI tag object."""
+
+    name: str
+    """name of the tag."""
+    description: str
+    """explanation of the tag."""
+    external_docs: ExternalDocs | None = Field(alias="externalDocs", default=None)
+    """external link to the doc."""
+
+
 class Configurator:
     """
     Configure and build an application.
@@ -51,30 +86,83 @@ class Configurator:
 
     def __init__(self, settings: Settings) -> None:
         """
-        :param settings: Application settings.
+        :param settings: application settings.
         """
         registry_cls = resolve(settings.registry_class)
         self.registry = registry_cls(settings)
-        self._app = FastAPI(
-            dependencies=[Depends(check_csrf())],
-            docs_url=None,
-            redoc_url=None,
-        )
         Route._registry = self.registry  # type: ignore
-        self._app.router.route_class = Route
+
+        self.middlewares: list[Tuple[Type[AbstractMiddleware], Any]] = []
+        self.exception_handlers: list[Tuple[int | Type[Exception], Any]] = []
+        self.mounts: list[Tuple[str, Path, str]] = []
+        self.tags: dict[str, OpenApiTag] = {}
+
+        self.api_title = "OpenAPI"
+        self.api_version = "v1"
+        self.api_description: str = ""
+        self.api_summary: str | None = None
+
+        self.router = Router()
         self.scanner = venusian.Scanner(fastlife=self)
         self.include("fastlife.views")
         self.include("fastlife.middlewares")
 
-    def get_asgi_app(self) -> FastAPI:
+    def build_asgi_app(self) -> FastAPI:
         """
-        Get the app after configuration in order to start after beeing configured.
+        Build the app after configuration in order to start after beeing configured.
 
         :return: FastAPI application.
         """
-        return self._app
-
-    def include(self, module: str | ModuleType) -> "Configurator":
+        _app = FastAPI(
+            title=self.api_title,
+            version=self.api_version,
+            description=self.api_description,
+            summary=self.api_summary,
+            dependencies=[Depends(check_csrf())],
+            docs_url=self.registry.settings.api_swagger_ui_url,
+            redoc_url=self.registry.settings.api_redocs_url,
+            openapi_tags=[tag.model_dump(by_alias=True) for tag in self.tags.values()]
+            if self.tags
+            else None,
+        )
+        _app.router.route_class = Route
+        for _route in self.router.routes:
+            route = cast(Route, _route)
+            _app.router.add_api_route(
+                path=route.path,
+                endpoint=route.endpoint,
+                response_model=route.response_model,
+                status_code=route.status_code,
+                tags=route.tags,
+                dependencies=route.dependencies,
+                summary=route.summary,
+                description=route.description,
+                response_description=route.response_description,
+                deprecated=route.deprecated,
+                methods=route.methods,
+                operation_id=route.operation_id,
+                response_model_include=route.response_model_include,
+                response_model_exclude=route.response_model_exclude,
+                response_model_by_alias=route.response_model_by_alias,
+                response_model_exclude_unset=route.response_model_exclude_unset,
+                response_model_exclude_defaults=route.response_model_exclude_defaults,
+                response_model_exclude_none=route.response_model_exclude_none,
+                include_in_schema=route.include_in_schema,
+                name=route.name,
+                openapi_extra=route.openapi_extra,
+            )
+
+        for middleware_class, options in self.middlewares:
+            _app.add_middleware(middleware_class, **options)  # type: ignore
+
+        for status_code_or_exc, exception_handler in self.exception_handlers:
+            _app.add_exception_handler(status_code_or_exc, exception_handler)
+
+        for route_path, directory, name in self.mounts:
+            _app.mount(route_path, StaticFiles(directory=directory), name=name)
+        return _app
+
+    def include(self, module: str | ModuleType) -> Self:
         """
         Include a module in order to load its configuration.
 
@@ -105,16 +193,61 @@ class Configurator:
         self.scanner.scan(module, categories=[VENUSIAN_CATEGORY])  # type: ignore
         return self
 
+    def set_locale_negociator(self, locale_negociator: "LocaleNegociator") -> Self:
+        """Install a locale negociator for the app."""
+        self.registry.locale_negociator = locale_negociator
+        return self
+
+    def add_translation_dirs(self, locales_dir: str) -> Self:
+        """
+        Add a translation directory for localization.
+
+        Usually, the locales is a directory from a package and has to be
+        passed with a `:` separator: {package_name}:locales.
+
+        :param locales_dir: the directory contains local inside a python package.
+        """
+        self.registry.localizer.load(locales_dir)
+        return self
+
+    def set_api_documentation_info(
+        self,
+        title: str,
+        version: str,
+        description: str,
+        summary: str | None = None,
+    ) -> Self:
+        """
+        Set your api documentation title for application that expose an API.
+
+        :param title: OpenAPI documentation title
+        :param version: OpenAPI api version
+        :param description: OpenAPI documentation description
+        :param summary: OpenAPI documentation summary
+        """
+        self.api_title = title
+        self.api_version = version
+        self.api_description = description
+        self.api_summary = summary
+        return self
+
+    def add_open_tag(self, tag: OpenApiTag) -> Self:
+        """Register a tag description in the documentation."""
+        if tag.name in self.tags:
+            raise ConfigurationError(f"Tag {tag.name} can't be registered twice.")
+        self.tags[tag.name] = tag
+        return self
+
     def add_middleware(
         self, middleware_class: Type[AbstractMiddleware], **options: Any
     ) -> Self:
         """
         Add a starlette middleware to the FastAPI app.
         """
-        self._app.add_middleware(middleware_class, **options)  # type: ignore
+        self.middlewares.append((middleware_class, options))
         return self
 
-    def add_route(
+    def add_api_route(
         self,
         name: str,
         path: str,
@@ -122,39 +255,44 @@ class Configurator:
         *,
         permission: str | None = None,
         status_code: int | None = None,
-        tags: List[Union[str, Enum]] | None = None,
-        summary: Optional[str] = None,
-        description: Optional[str] = None,
+        tags: list[str | Enum] | None = None,
+        summary: str | None = None,
+        description: str | None = None,
         response_description: str = "Successful Response",
-        # responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
-        deprecated: Optional[bool] = None,
-        methods: Optional[List[str]] = None,
-        # operation_id: Optional[str] = None,
+        # responses: Dict[Union[int, str], Dict[str, Any]] | None = None,
+        deprecated: bool | None = None,
+        methods: list[str] | None = None,
+        operation_id: str | None = None,
         # response_model: Any = Default(None),
-        # response_model_include: Optional[IncEx] = None,
-        # response_model_exclude: Optional[IncEx] = None,
-        # response_model_by_alias: bool = True,
-        # response_model_exclude_unset: bool = False,
-        # response_model_exclude_defaults: bool = False,
-        # response_model_exclude_none: bool = False,
-        # include_in_schema: bool = True,
+        response_model_include: IncEx | None = None,
+        response_model_exclude: IncEx | None = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        include_in_schema: bool = True,
         # response_class: Union[Type[Response], DefaultPlaceholder] = Default(
         #     HTMLResponse
         # ),
-        # openapi_extra: Optional[Dict[str, Any]] = None,
+        openapi_extra: dict[str, Any] | None = None,
         # generate_unique_id_function: Callable[[APIRoute], str] = Default(
         #     generate_unique_id
         # ),
-    ) -> "Configurator":
+    ) -> Self:
         """
-        Add a route to the app.
+        Add an API route to the app.
 
         Fastlife does not use a decorator to attach routes, instead the decorator
-        :func:`fastlife.config.configurator.configure` has to be used to
+        {func}`fastlife.config.configurator.configure` has to be used to
         inject routes inside a method and call the add_route method.
 
+        This route has to be used to add API Route, by API, to expose it in the
+        documentation.
+
+        To add a route that serve HTML user the method {meth}`Configurator.add_route`
+
         :param name: name of the route, used to build route from the helper
-            :meth:`fastlife.request.request.Request.url_for` in order to create links.
+            {meth}`fastlife.request.request.Request.url_for` in order to create links.
         :param path: path of the route, use `{curly_brace}` to inject FastAPI Path
             parameters.
         :param endpoint: the function that will reveive the request.
@@ -162,15 +300,33 @@ class Configurator:
             :attr:`fastlife.config.settings.Settings.check_permission` function.
 
         :param methods: restrict route to a list of http methods.
-        :param response_description: description for the response.
-        :param deprecated: mark the route as deprecated.
+        :param description:OpenAPI description for the route.
+        :param summary: OpenAPI summary for the route.
+        :param response_description: OpenAPI description for the response.
+        :param operation_id: OpenAPI optional unique string used to identify an
+            operation.
+        :param tags: OpenAPI tags for the route.
+        :param deprecated: OpenAPI deprecated annotation for the route.
+
+        :param response_model_include: customize fields list to include in repsonse.
+        :param response_model_exclude: customize fields list to exclude in repsonse.
+        :param response_model_by_alias: serialize fields by alias or by name if False.
+        :param response_model_exclude_unset: exclude fields that are not explicitly
+            set in response.
+        :param response_model_exclude_defaults: exclude default value of response
+            fields.
+        :param response_model_exclude_none: exclude fields instead of serialize to
+            null value.
+        :param include_in_schema: expose or not the route in the doc.
+        :param openapi_extra: open api documentation extra fields.
+
         :return: the configurator.
         """
-        dependencies: List[DependsType] = []
+        dependencies: list[DependsType] = []
         if permission:
             dependencies.append(Depends(self.registry.check_permission(permission)))
 
-        self._app.add_api_route(
+        self.router.add_api_route(
             path,
             endpoint,
             # response_model=response_model,
@@ -183,24 +339,85 @@ class Configurator:
             # responses=responses,
             deprecated=deprecated,
             methods=methods,
-            # operation_id=operation_id,
-            # response_model_include=response_model_include,
-            # response_model_exclude=response_model_exclude,
-            # response_model_by_alias=response_model_by_alias,
-            # response_model_exclude_unset=response_model_exclude_unset,
-            # response_model_exclude_defaults=response_model_exclude_defaults,
-            # response_model_exclude_none=response_model_exclude_none,
-            # include_in_schema=include_in_schema,
+            operation_id=operation_id or name,
+            response_model_include=response_model_include,
+            response_model_exclude=response_model_exclude,
+            response_model_by_alias=response_model_by_alias,
+            response_model_exclude_unset=response_model_exclude_unset,
+            response_model_exclude_defaults=response_model_exclude_defaults,
+            response_model_exclude_none=response_model_exclude_none,
+            include_in_schema=include_in_schema,
             # response_class=response_class,
             name=name,
-            # openapi_extra=openapi_extra,
+            openapi_extra=openapi_extra,
             # generate_unique_id_function=generate_unique_id_function,
         )
         return self
 
+    def add_route(
+        self,
+        name: str,
+        path: str,
+        endpoint: Callable[..., Any],
+        *,
+        permission: str | None = None,
+        template: str | None = None,
+        status_code: int | None = None,
+        methods: list[str] | None = None,
+    ) -> Self:
+        """
+        Add a route to the app.
+
+        Fastlife does not use the FastAPI decorator to attach routes, instead the
+        decorator {func}`@configure <fastlife.config.configurator.configure>` has to
+        be used to inject routes inside a method and call the add_route method.
+        Or the decorator {func}`@view_config <fastlife.config.views.view_config>`
+        can decorate view functions.
+
+        :param name: name of the route, used to build route from the helper
+            {meth}`fastlife.request.request.Request.url_for` in order to create links.
+        :param path: path of the route, use `{curly_brace}` to inject FastAPI Path
+            parameters.
+        :param endpoint: the function that will reveive the request.
+        :param permission: a permission to validate by the
+            :attr:`fastlife.config.settings.Settings.check_permission` function.
+
+        :param methods: restrict route to a list of http methods.
+        :return: the configurator.
+        """
+        dependencies: list[DependsType] = []
+        if permission:
+            dependencies.append(Depends(self.registry.check_permission(permission)))
+
+        if template:
+
+            def render(
+                request: Request,
+                resp: Annotated[Response | Mapping[str, Any], Depends(endpoint)],
+            ) -> Response:
+                if isinstance(resp, Response):
+                    return resp
+                return request.registry.get_renderer(template)(request).render(
+                    template,
+                    params=resp,
+                )
+
+            endpoint = render
+
+        self.router.add_api_route(
+            path,
+            endpoint,
+            status_code=status_code,
+            dependencies=dependencies,
+            methods=methods,
+            include_in_schema=False,
+            name=name,
+        )
+        return self
+
     def add_static_route(
         self, route_path: str, directory: Path, name: str = "static"
-    ) -> "Configurator":
+    ) -> Self:
         """
         Mount a directory to an http endpoint.
 
@@ -210,24 +427,61 @@ class Configurator:
         :return: the configurator
 
         """
-        self._app.mount(route_path, StaticFiles(directory=directory), name=name)
+        self.mounts.append((route_path, directory, name))
         return self
 
     def add_exception_handler(
-        self, status_code_or_exc: int | Type[Exception], handler: Any
-    ) -> "Configurator":
-        """Add an exception handler the application."""
+        self,
+        status_code_or_exc: int | Type[Exception],
+        handler: Any,
+        *,
+        template: str | None = None,
+        status_code: int = 500,
+    ) -> Self:
+        """
+        Add an exception handler the application.
+
+        """
 
         def exception_handler(request: BaseRequest, exc: Exception) -> Any:
-            req = Request(self.registry, request)
-            return handler(req, exc)
+            request = Request(self.registry, request)
+            resp = handler(request, exc)
+            if isinstance(resp, Response):
+                return resp
+
+            if not template:
+                raise RuntimeError(
+                    "No template set for "
+                    f"{exc.__module__}:{exc.__class__.__qualname__} but "
+                    f"{handler.__module__}:{handler.__qualname__} "
+                    "did not return a Response"
+                )
+
+            return request.registry.get_renderer(template)(request).render(
+                template,
+                params=resp,
+                status_code=status_code,
+            )
+
+        self.exception_handlers.append((status_code_or_exc, exception_handler))
+        return self
 
-        self._app.add_exception_handler(status_code_or_exc, exception_handler)
+    def add_renderer(
+        self, file_ext: str, renderer: "AbstractTemplateRendererFactory"
+    ) -> Self:
+        """
+        Add a render for a given file extension.
+
+        :param file_ext: the file extention of your templates.
+        :param renderer: the renderer that will render the template.
+        """
+        # we don't want to expose the renderer publicly as mutable
+        self.registry.renderers[f".{file_ext.lstrip('.')}"] = renderer  # type: ignore
         return self
 
 
 def configure(
-    wrapped: Callable[[Configurator], None]
+    wrapped: Callable[[Configurator], None],
 ) -> Callable[[Configurator], None]:
     """
     Decorator used to attach route in a submodule while using the configurator.include.