fastlifeweb 0.20.1__py3-none-any.whl → 0.22.0__py3-none-any.whl

fastlife/adapters/jinjax/widgets/sequence.py

@@ -2,52 +2,73 @@ from collections.abc import Sequence
 from typing import Any
 
 from markupsafe import Markup
+from pydantic import Field
 
-from fastlife.services.templates import AbstractTemplateRenderer
-
-from .base import TypeWrapper, Widget
-
-
-class SequenceWidget(Widget[Sequence[Widget[Any]]]):
-    def __init__(
-        self,
-        name: str,
-        *,
-        title: str | None,
-        hint: str | None = None,
-        aria_label: str | None = None,
-        value: Sequence[Widget[Any]] | None,
-        error: str | None = None,
-        item_type: type[Any],
-        token: str,
-        removable: bool,
-    ):
-        super().__init__(
-            name,
-            value=value,
-            error=error,
-            title=title,
-            hint=hint,
-            aria_label=aria_label,
-            token=token,
-            removable=removable,
-        )
-        self.item_type = item_type
-
-    def get_template(self) -> str:
-        return "pydantic_form.Sequence.jinja"
+from fastlife.service.templates import AbstractTemplateRenderer
+
+from .base import TWidget, TypeWrapper, Widget
+
+
+class SequenceWidget(Widget[Sequence[TWidget]]):
+    template = """
+    <pydantic_form.Widget :widget_id="id" :removable="removable">
+      <Details :id="id">
+        <Summary :id="id + '-summary'">
+          <H3 :class="H3_SUMMARY_CLASS">{{title}}</H3>
+          <pydantic_form.Error :text="error" />
+        </Summary>
+        <div>
+          {% set fnGetName = "get" + id.replace("-", "_") %}
+          <script>
+            function {{ fnGetName }} () {
+              const el = document.getElementById("{{id}}-content");
+              const len = el.dataset.length;
+              el.dataset.length = parseInt(len) + 1;
+              return "{{wrapped_type.name}}." + len;
+            }
+          </script>
+
+          <div id="{{id}}-content" class="m-4"
+            data-length="{{children_widgets|length|string}}">
+            {% set container_id = id + "-children-container" %}
+            <div id="{{container_id}}">
+              {% for child in children_widgets %}
+              {{ child }}
+              {% endfor%}
+            </div>
+          </div>
+
+          <div>
+            {% set container_id = "#" + id + "-children-container" %}
+            {% set add_id = id + "-add" %}
+            {% set vals = 'js:{"name": '
+                + fnGetName
+                + '(), "token": "'
+                + wrapped_type.token + '", "removable": true}' %}
+            <Button type="button"
+                :hx-target="container_id" hx-swap="beforeend"
+                :id="add_id"
+                :hx-vals="vals"
+                :hx-get="wrapped_type.url">
+              Add
+            </Button>
+          </div>
+        </div>
+      </Details>
+    </pydantic_form.Widget>
+    """
+
+    item_type: type[Any]
+    wrapped_type: TypeWrapper | None = Field(default=None)
+    children_widgets: list[str] = Field(default=None)
 
     def build_item_type(self, route_prefix: str) -> TypeWrapper:
         return TypeWrapper(self.item_type, route_prefix, self.name, self.token)
 
     def to_html(self, renderer: "AbstractTemplateRenderer") -> Markup:
         """Return the html version."""
-        children = [Markup(item.to_html(renderer)) for item in self.value or []]
-        return Markup(
-            renderer.render_template(
-                self.get_template(),
-                widget=self,
-                type=self.build_item_type(renderer.route_prefix),
-                children_widgets=children,
-            )
-        )
+        self.wrapped_type = self.build_item_type(renderer.route_prefix)
+        self.children_widgets = [
+            Markup(item.to_html(renderer)) for item in self.value or []
+        ]
+        return Markup(renderer.render_template(self))

fastlife/adapters/jinjax/widgets/text.py

@@ -1,52 +1,31 @@
 from collections.abc import Sequence
 
+from pydantic import Field
+
+from fastlife.domain.model.types import Builtins
+
 from .base import Widget
 
 
-class TextWidget(Widget[str]):
+class TextWidget(Widget[Builtins]):
     """
     Widget for text like field (email, ...).
-
-    :param name: input name.
-    :param title: title for the widget.
-    :param hint: hint for human.
-    :param aria_label: html input aria-label value.
-    :param placeholder: html input placeholder value.
-    :param error: error of the value if any.
-    :param value: current value.
-    :param removable: display a button to remove the widget for optional fields.
-    :param token: token used to get unique id on the form.
     """
 
-    def __init__(
-        self,
-        name: str,
-        *,
-        title: str | None,
-        hint: str | None = None,
-        aria_label: str | None = None,
-        placeholder: str | None = None,
-        error: str | None = None,
-        value: str = "",
-        input_type: str = "text",
-        removable: bool = False,
-        token: str,
-    ) -> None:
-        super().__init__(
-            name,
-            value=value,
-            title=title,
-            hint=hint,
-            aria_label=aria_label,
-            token=token,
-            error=error,
-            removable=removable,
-        )
-        self.placeholder = placeholder or ""
-        self.input_type = input_type
+    template = """
+    <pydantic_form.Widget :widget_id="id" :removable="removable">
+      <div class="pt-4">
+        <Label :for="id">{{title}}</Label>
+        <pydantic_form.Error :text="error" />
+        <Input :name="name" :value="value" :type="input_type" :id="id"
+          :aria-label="aria_label" :placeholder="placeholder" />
+        <pydantic_form.Hint :text="hint" />
+      </div>
+    </pydantic_form.Widget>
+    """
 
-    def get_template(self) -> str:
-        return "pydantic_form.Text.jinja"
+    input_type: str = Field(default="text")
+    placeholder: str | None = Field(default=None)
 
 
 class TextareaWidget(Widget[Sequence[str]]):
@@ -54,12 +33,13 @@ class TextareaWidget(Widget[Sequence[str]]):
     Render a Textearea for a string or event a sequence of string.
 
     ```
+    from fastlife.adapters.jinjax.widgets.base import CustomWidget
     from fastlife.adapters.jinjax.widgets.text import TextareaWidget
     from pydantic import BaseModel, Field, field_validator
 
     class TaggedParagraphForm(BaseModel):
-        paragraph: Annotated[str, TextareaWidget] = Field(...)
-        tags: Annotated[Sequence[str], TextareaWidget] = Field(
+        paragraph: Annotated[str, CustomWidget(TextareaWidget)] = Field(...)
+        tags: Annotated[Sequence[str], CustomWidget(TextareaWidget)] = Field(
             default_factory=list,
             title="Tags",
             description="One tag per line",
@@ -69,43 +49,24 @@ class TextareaWidget(Widget[Sequence[str]]):
         def split(cls, s: Any) -> Sequence[str]:
             return s.split() if s else []
     ```
-
-    :param name: input name.
-    :param title: title for the widget.
-    :param hint: hint for human.
-    :param aria_label: html input aria-label value.
-    :param placeholder: html input placeholder value.
-    :param error: error of the value if any.
-    :param value: current value.
-    :param removable: display a button to remove the widget for optional fields.
-    :param token: token used to get unique id on the form.
-
     """
 
-    def __init__(
-        self,
-        name: str,
-        *,
-        title: str | None,
-        hint: str | None = None,
-        aria_label: str | None = None,
-        placeholder: str | None = None,
-        error: str | None = None,
-        value: Sequence[str] | None = None,
-        removable: bool = False,
-        token: str,
-    ) -> None:
-        super().__init__(
-            name,
-            value=value or [],
-            title=title,
-            hint=hint,
-            aria_label=aria_label,
-            token=token,
-            error=error,
-            removable=removable,
-        )
-        self.placeholder = placeholder or ""
+    template = """
+    <pydantic_form.Widget :widget_id="id" :removable="removable">
+      <div class="pt-4">
+        <Label :for="id">{{title}}</Label>
+        <pydantic_form.Error :text="error" />
+        <Textarea :name="name" :id="id" :aria-label="aria_label">
+            {%- if v is string -%}
+            {{- v -}}}
+            {%- else -%}
+            {%- for v in value %}{{v}}
+    {% endfor -%}
+            {% endif %}
+        </Textarea>
+        <pydantic_form.Hint :text="hint" />
+      </div>
+    </pydantic_form.Widget>
+    """
 
-    def get_template(self) -> str:
-        return "pydantic_form.Textarea.jinja"
+    placeholder: str = Field(default="")

fastlife/adapters/jinjax/widgets/union.py

@@ -3,57 +3,59 @@ Widget for field of type Union.
 """
 
 from collections.abc import Sequence
-from typing import Any, Union
+from typing import Union
 
 from markupsafe import Markup
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
-from fastlife.services.templates import AbstractTemplateRenderer
+from fastlife.service.templates import AbstractTemplateRenderer
 
-from .base import TypeWrapper, Widget
+from .base import TWidget, TypeWrapper, Widget
 
 
-class UnionWidget(Widget[Widget[Any]]):
+class UnionWidget(Widget[TWidget]):
     """
     Widget for union types.
+    """
 
-    :param name: input name.
-    :param title: title for the widget.
-    :param hint: hint for human.
-    :param aria_label: html input aria-label value.
-    :param value: current value.
-    :param error: error of the value if any.
-    :param children_types: childrens types list.
-    :param removable: display a button to remove the widget for optional fields.
-    :param token: token used to get unique id on the form.
-
+    template = """
+    <pydantic_form.Widget :widget_id="id" :removable="removable">
+      <div id="{{id}}">
+        <Details>
+          <Summary :id="id + '-union-summary'">
+            <H3 :class="H3_SUMMARY_CLASS">{{title}}</H3>
+            <pydantic_form.Error :text="error" />
+          </Summary>
+          <div hx-sync="this" id="{{id}}-child">
+            {% if child %}
+            {{ child }}
+            {% else %}
+            {% for typ in types %}
+            <Button type="button"
+                hx-target="closest div"
+                :hx-get="typ.url"
+                :hx-vals="typ.params|tojson"
+                :id="typ.id"
+                onclick={{ "document.getElementById('" + id + "-remove-btn').hidden=false" }}
+              :class="SECONDARY_BUTTON_CLASS">{{typ.title}}</Button>
+            {% endfor %}
+            {% endif %}
+          </div>
+          <Button type="button" :id="id + '-remove-btn'" :hx-target="'#' + id"
+            :hx-vals="parent_type.params|tojson" :hx-get="parent_type.url" :hidden="not child"
+            :class="SECONDARY_BUTTON_CLASS">
+            Remove
+          </Button>
+        </Details>
+      </div>
+    </pydantic_form.Widget>
     """
 
-    def __init__(
-        self,
-        name: str,
-        *,
-        title: str | None,
-        hint: str | None = None,
-        aria_label: str | None = None,
-        value: Widget[Any] | None,
-        error: str | None = None,
-        children_types: Sequence[type[BaseModel]],
-        removable: bool = False,
-        token: str,
-    ):
-        super().__init__(
-            name,
-            value=value,
-            error=error,
-            title=title,
-            hint=hint,
-            aria_label=aria_label,
-            token=token,
-            removable=removable,
-        )
-        self.children_types = children_types
-        self.parent_name = name
+    children_types: Sequence[type[BaseModel]]
+    parent_type: TypeWrapper | None = Field(default=None)
+
+    types: Sequence[TypeWrapper] | None = Field(default=None)
+    child: str = Field(default="")
 
     def build_types(self, route_prefix: str) -> Sequence[TypeWrapper]:
         """Wrap types in the union in order to get the in their own widgets."""
@@ -62,24 +64,15 @@ class UnionWidget(Widget[Widget[Any]]):
             for typ in self.children_types
         ]
 
-    def get_template(self) -> str:
-        return "pydantic_form.Union.jinja"
-
     def to_html(self, renderer: "AbstractTemplateRenderer") -> Markup:
         """Return the html version."""
-        child = Markup(self.value.to_html(renderer)) if self.value else ""
-        return Markup(
-            renderer.render_template(
-                self.get_template(),
-                widget=self,
-                types=self.build_types(renderer.route_prefix),
-                parent_type=TypeWrapper(
-                    Union[tuple(self.children_types)],  # type: ignore # noqa: UP007
-                    renderer.route_prefix,
-                    self.parent_name,
-                    self.token,
-                    title=self.title,
-                ),
-                child=child,
-            )
+        self.child = Markup(self.value.to_html(renderer)) if self.value else ""
+        self.types = self.build_types(renderer.route_prefix)
+        self.parent_type = TypeWrapper(
+            Union[tuple(self.children_types)],  # type: ignore # noqa: UP007
+            renderer.route_prefix,
+            self.name,
+            self.token,
+            title=self.title,
         )
+        return Markup(renderer.render_template(self))

fastlife/components/CsrfToken.jinja

@@ -2,4 +2,4 @@
   a :jinjax:component:`Hidden` field automaticaly injected in every
   :jinjax:component:`Form` to protect against CSRF Attacks.
 #}
-<Hidden :name="csrf_token.name" :value="csrf_token.value" />
+<Hidden :name="request.csrf_token.name" :value="request.csrf_token.value" />

fastlife/components/Form.jinja

@@ -2,7 +2,7 @@
   Create html ``<form>`` node with htmx support by default.
   A :jinjax:component:`CsrfToken` will always be included in the form
   and will be checked by the
-  :func:`csrf policy method <fastlife.security.csrf.check_csrf>`.
+  :func:`csrf policy method <fastlife.service.csrf.check_csrf>`.
 
   ::
 

fastlife/components/pydantic_form/FatalError.jinja

@@ -0,0 +1,8 @@
+{# doc display an error for a field. #}
+{# def message: Annotated[str | None, "error message"] #}
+{%- if message -%}
+<div class="flex items-center bg-red-50 border border-red-400 text-red-700" role="alert">
+  <icons.Fire class="m-3 w-16 h-16 fill-orange-500" />
+  <span class="sm:inline text-xl">{{ message }}</span>
+</div>
+{%- endif -%}

fastlife/components/pydantic_form/Widget.jinja

@@ -1,11 +1,12 @@
 {# doc Base component for widget #}
 {# def
-widget: Annotated[fastlife.adapters.jinjax.widgets.base.Widget, "widget to display."],
+widget_id: Annotated[str, "widget to display."],
+removable: Annotated[bool, "Set to true to add a remove button"],
 #}
-{% set container_id = widget.id + "-container" %}
+{% set container_id = widget_id + "-container" %}
 <div id="{{container_id}}">
   {{ content }}
-  {% if widget.removable %}
+  {% if removable %}
   <Button type="button" :onclick={{"document.getElementById('" + container_id + "').remove()" }}>
     Remove
   </Button>

fastlife/config/__init__.py

@@ -1,19 +1,16 @@
 """Configure fastlife app for dependency injection."""
 
 from .configurator import Configurator, GenericConfigurator, configure
-from .registry import DefaultRegistry, GenericRegistry
+from .exceptions import exception_handler
 from .resources import resource, resource_view
-from .settings import Settings
 from .views import view_config
 
 __all__ = [
     "Configurator",
     "GenericConfigurator",
     "configure",
-    "view_config",
+    "exception_handler",
     "resource",
     "resource_view",
-    "GenericRegistry",
-    "DefaultRegistry",
-    "Settings",
+    "view_config",
 ]

fastlife/config/configurator.py

@@ -12,8 +12,9 @@ phase.
 """
 
 import logging
+from asyncio import iscoroutine
 from collections import defaultdict
-from collections.abc import Callable, Mapping, Sequence
+from collections.abc import Callable, Sequence
 from enum import Enum
 from pathlib import Path
 from types import ModuleType
@@ -26,25 +27,29 @@ from fastapi.params import Depends as DependsType
 from fastapi.staticfiles import StaticFiles
 from fastapi.types import IncEx
 
+from fastlife.adapters.fastapi.request import GenericRequest, Request
+from fastlife.adapters.fastapi.routing.route import Route
+from fastlife.adapters.fastapi.routing.router import Router
 from fastlife.config.openapiextra import OpenApiTag
+from fastlife.domain.model.template import InlineTemplate
 from fastlife.middlewares.base import AbstractMiddleware
-from fastlife.request.request import GenericRequest, Request
-from fastlife.routing.route import Route
-from fastlife.routing.router import Router
-from fastlife.security.csrf import check_csrf
-from fastlife.services.policy import check_permission
-from fastlife.shared_utils.resolver import resolve, resolve_maybe_relative
-
-from .registry import DefaultRegistry, TRegistry
-from .settings import Settings
+from fastlife.service.check_permission import check_permission
+from fastlife.service.csrf import check_csrf
+from fastlife.service.registry import DefaultRegistry, TRegistry
+from fastlife.settings import Settings
+from fastlife.shared_utils.infer import is_inline_template_returned
+from fastlife.shared_utils.resolver import (
+    resolve,
+    resolve_maybe_relative,
+)
 
 if TYPE_CHECKING:
-    from fastlife.security.policy import AbstractSecurityPolicy  # coverage: ignore
-    from fastlife.services.templates import (
+    from fastlife.service.security_policy import AbstractSecurityPolicy
+    from fastlife.service.templates import (
         AbstractTemplateRendererFactory,  # coverage: ignore
     )
 
-from fastlife.services.locale_negociator import LocaleNegociator
+from fastlife.service.locale_negociator import LocaleNegociator
 
 log = logging.getLogger(__name__)
 VENUSIAN_CATEGORY = "fastlife"
@@ -143,6 +148,8 @@ class GenericConfigurator(Generic[TRegistry]):
         ] = {}
 
         self._registered_permissions: set[str] = set()
+
+        self._renderer_globals: dict[str, Any] = {}
         self.scanner = venusian.Scanner(fastlife=self)
         self.include("fastlife.views")
         self.include("fastlife.middlewares")
@@ -441,6 +448,53 @@ class GenericConfigurator(Generic[TRegistry]):
         )
         return self
 
+    def add_renderer_global(
+        self, name: str, value: Any, *, evaluate: bool = True
+    ) -> None:
+        """
+        Add a rendering global value.
+
+        :param name: the name or key of the global value available in the template.
+        :param value: a value, or a callable or
+            an async function with a request in parameter that will evaluate the value.
+        :param evaluate: set to false if you want to inject helper methods in the
+            template.
+        """
+        self._renderer_globals[name] = value, evaluate
+
+    async def _build_renderer_globals(self, request: Request) -> dict[str, Any]:
+        """
+        Build globals variables accessible in any templates.
+
+        * `request` is the {class}`current request <fastlife.request.request.Request>`
+        * `authenticated_user` is used to access to the authenticated user if the
+            security policy has been installed.
+        * `csrf_token` is used to build for {jinjax:component}`CsrfToken`.
+        * `gettext`, `ngettext`, `dgettext`, `dngettext`, `pgettext`, `dpgettext`,
+        `npgettext`, `dnpgettext` methods are installed for i18n purpose.
+        """
+        lczr = request.registry.localizer(request)
+        custom_globals = {}
+        for key, (val, evaluate) in self._renderer_globals.items():
+            if evaluate and callable(val):
+                val = val(request)
+                if iscoroutine(val):
+                    val = await val
+            custom_globals[key] = val
+        return {
+            "request": request,
+            "gettext": lczr.gettext,
+            "ngettext": lczr.ngettext,
+            "dgettext": lczr.dgettext,
+            "dngettext": lczr.dngettext,
+            "pgettext": lczr.pgettext,
+            "dpgettext": lczr.dpgettext,
+            "npgettext": lczr.npgettext,
+            "dnpgettext": lczr.dnpgettext,
+            **custom_globals,
+            **request.renderer_globals,
+        }
+
     def add_route(
         self,
         name: str,
@@ -466,10 +520,8 @@ class GenericConfigurator(Generic[TRegistry]):
         :param path: path of the route, use `{curly_brace}` to inject FastAPI Path
             parameters.
         :param endpoint: the function that will reveive the request.
-        :param template: the template rendered by the
-            {class}`fastlife.service.templates.AbstractTemplateRenderer`.
         :param permission: a permission to validate by the
-            {class}`Security Policy <fastlife.security.policy.AbstractSecurityPolicy>`.
+            {class}`Security Policy <fastlife.service.security_policy.AbstractSecurityPolicy>`.
         :param status_code: customize response status code.
         :param methods: restrict route to a list of http methods.
         :return: the configurator.
@@ -479,17 +531,21 @@ class GenericConfigurator(Generic[TRegistry]):
             self._registered_permissions.add(permission)
             dependencies.append(Depends(check_permission(permission)))
 
-        if template:
+        if is_inline_template_returned(endpoint):
 
-            def render(
+            async def render(
                 request: Request,
-                resp: Annotated[Response | Mapping[str, Any], Depends(endpoint)],
+                resp: Annotated["Response | InlineTemplate", Depends(endpoint)],
             ) -> Response:
                 if isinstance(resp, Response):
                     return resp
+
+                template = resp.renderer
+                globs = await self._build_renderer_globals(request)
                 return request.registry.get_renderer(template)(request).render(
                     template,
                     params=resp,
+                    globals=globs,
                 )
 
             endpoint = render
@@ -523,9 +579,8 @@ class GenericConfigurator(Generic[TRegistry]):
     def add_exception_handler(
         self,
         status_code_or_exc: int | type[Exception],
-        handler: Any,
+        handler: Callable[..., "Response | InlineTemplate"],
         *,
-        template: str | None = None,
         status_code: int = 500,
     ) -> Self:
         """
@@ -533,7 +588,7 @@ class GenericConfigurator(Generic[TRegistry]):
 
         """
 
-        def exception_handler(request: BaseRequest, exc: Exception) -> Any:
+        async def exception_handler(request: BaseRequest, exc: Exception) -> Any:
             # FastAPI exception handler does not provide our request object
             # it seems like it is rebuild from the asgi scope. Even the router
             # class is wrong.
@@ -544,18 +599,11 @@ class GenericConfigurator(Generic[TRegistry]):
             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 req.registry.get_renderer(template)(req).render(
-                template,
+            return req.registry.get_renderer(resp.renderer)(req).render(
+                resp.template,
                 params=resp,
                 status_code=status_code,
+                globals=(await self._build_renderer_globals(req)),
             )
 
         self.exception_handlers.append((status_code_or_exc, exception_handler))