fastlifeweb 0.20.0__py3-none-any.whl → 0.21.0__py3-none-any.whl

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 .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/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/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
@@ -34,6 +35,7 @@ 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 fastlife.templates.inline import is_inline_template_returned
 
 from .registry import DefaultRegistry, TRegistry
 from .settings import Settings
@@ -43,6 +45,7 @@ if TYPE_CHECKING:
     from fastlife.services.templates import (
         AbstractTemplateRendererFactory,  # coverage: ignore
     )
+    from fastlife.templates.inline import InlineTemplate
 
 from fastlife.services.locale_negociator import LocaleNegociator
 
@@ -143,6 +146,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 +446,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,8 +518,6 @@ 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>`.
         :param status_code: customize response status code.
@@ -479,17 +529,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 +577,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 +586,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 +597,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))

fastlife/config/exceptions.py

@@ -11,7 +11,6 @@ from .configurator import VENUSIAN_CATEGORY, Configurator
 def exception_handler(
     exception: type[Exception],
     *,
-    template: str | None = None,
     status_code: int | None = None,
 ) -> Callable[..., Any]:
     """
@@ -34,7 +33,6 @@ def exception_handler(
             config.add_exception_handler(
                 exception,
                 wrapped,
-                template=template,
                 **({} if status_code is None else {"status_code": status_code}),
             )
 

fastlife/config/views.py

@@ -31,7 +31,6 @@ def view_config(
     path: str,
     *,
     permission: str | None = None,
-    template: str | None = None,
     status_code: int | None = None,
     methods: list[str] | None = None,
 ) -> Callable[..., Any]:
@@ -72,7 +71,6 @@ def view_config(
                 permission=permission,
                 status_code=status_code,
                 methods=methods,
-                template=template,
             )
 
         venusian.attach(wrapped, callback, category=VENUSIAN_CATEGORY)  # type: ignore

fastlife/domain/__init__.py

@@ -0,0 +1 @@
+"""Framework core domain."""

fastlife/domain/model/__init__.py

@@ -0,0 +1 @@
+"""Core Domain Classes."""

fastlife/domain/model/security.py

@@ -0,0 +1,19 @@
+"""Models relative to the security."""
+
+import secrets
+
+from pydantic import BaseModel
+
+
+def create_csrf_token() -> str:
+    """A helper that create a csrf token."""
+    return secrets.token_urlsafe(5)
+
+
+class CSRFToken(BaseModel):
+    """Represent the CSRF Token"""
+
+    name: str
+    """Name of the token while serialized."""
+    value: str
+    """Value that must match between parts, cookie and posted form."""

fastlife/domain/model/template.py

@@ -0,0 +1,30 @@
+"""Inline templates."""
+
+from typing import ClassVar
+
+from pydantic import BaseModel
+from pydantic.config import ConfigDict
+
+
+class InlineTemplate(BaseModel):
+    """
+    Inline templates are used to encourage the location of behavior and the view typing.
+
+    Pages produce templates that are not reusable and don't need to be reusable
+    in there essence, they don't need to be in a component library.
+    They use a component lirary to stay small but contains a view logic
+    tighly coupled with the view and its code can stay in the same module of that view.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    template: ClassVar[str]
+    """The template string to render."""
+    renderer: ClassVar[str]
+    """Template render engine to use."""
+
+
+class JinjaXTemplate(InlineTemplate):
+    """Template that render JinjaX"""
+
+    renderer = ".jinja"

fastlife/domain/model/types.py

@@ -0,0 +1,17 @@
+"""Types that are serialized over HTTP and forms."""
+
+from decimal import Decimal
+from typing import Any
+from uuid import UUID
+
+from pydantic.networks import EmailStr
+
+Builtins = str | int | str | float | Decimal | UUID | EmailStr
+"""Builtins types."""
+
+
+AnyLiteral = Any
+"""
+Something like Literal[...] or Literal[...] which does not exists
+or Idon't know where it is hidden.
+"""

fastlife/request/request.py

@@ -6,6 +6,7 @@ from fastapi import Request as FastAPIRequest
 from fastapi.params import Depends
 
 from fastlife.config.registry import DefaultRegistry, TRegistry
+from fastlife.domain.model.security import CSRFToken, create_csrf_token
 
 if TYPE_CHECKING:
     from fastlife.security.policy import (  # coverage: ignore
@@ -25,11 +26,29 @@ class GenericRequest(FastAPIRequest, Generic[TRegistry]):
     security_policy: "AbstractSecurityPolicy[Any, TRegistry] | None"
     """Request locale used for the i18n of the response."""
 
+    renderer_globals: dict[str, Any]
+
     def __init__(self, registry: TRegistry, request: FastAPIRequest) -> None:
         super().__init__(request.scope, request.receive)
         self.registry = registry
         self.locale_name = registry.locale_negociator(self)
         self.security_policy = None  # build it from the ? registry
+        self.renderer_globals = {}
+        self._csrf_token: CSRFToken | None = None
+
+    @property
+    def csrf_token(self) -> CSRFToken:
+        if self._csrf_token is None:
+            name = self.registry.settings.csrf_token_name
+            value = self.cookies.get(name) or create_csrf_token()
+            self._csrf_token = CSRFToken(name=name, value=value)
+        return self._csrf_token
+
+    def add_renderer_globals(self, **kwargs: Any) -> None:
+        """
+        Add global variables to the template renderer context for the current request.
+        """
+        self.renderer_globals.update(kwargs)
 
     async def has_permission(
         self, permission: str

fastlife/security/csrf.py

@@ -18,7 +18,6 @@ no way to prevent to set the cookie in the request.
 
 """
 
-import secrets
 from collections.abc import Callable, Coroutine
 from typing import Any
 
@@ -31,11 +30,6 @@ class CSRFAttack(Exception):
     """
 
 
-def create_csrf_token() -> str:
-    """A helper that create a csrf token."""
-    return secrets.token_urlsafe(5)
-
-
 def check_csrf() -> Callable[[Request], Coroutine[Any, Any, bool]]:
     """
     A global application dependency, that is always active.
@@ -56,15 +50,11 @@ def check_csrf() -> Callable[[Request], Coroutine[Any, Any, bool]]:
             != "application/x-www-form-urlencoded"
         ):
             return True
-        csrf_token_name = request.registry.settings.csrf_token_name
-
-        cookie = request.cookies.get(csrf_token_name)
-        if not cookie:
-            raise CSRFAttack("CSRF token did not match")
 
+        token = request.csrf_token
         form_data = await request.form()
-        value = form_data.get(csrf_token_name)
-        if value != cookie:
+        value = form_data.get(token.name)
+        if value != token.value:
             raise CSRFAttack("CSRF token did not match")
 
         return True

fastlife/services/templates.py

@@ -9,11 +9,10 @@ More template engine can be registered using the configurator method
 """
 
 import abc
-from collections.abc import Callable, Mapping
+from collections.abc import Mapping
 from typing import Any
 
 from fastlife import Request, Response
-from fastlife.security.csrf import create_csrf_token
 from fastlife.templates.inline import InlineTemplate
 
 TemplateParams = Mapping[str, Any]
@@ -30,6 +29,7 @@ class AbstractTemplateRenderer(abc.ABC):
 
     def __init__(self, request: Request) -> None:
         self.request = request
+        self.globals: dict[str, Any] = {}
 
     @property
     def route_prefix(self) -> str:
@@ -43,27 +43,21 @@ class AbstractTemplateRenderer(abc.ABC):
         status_code: int = 200,
         content_type: str = "text/html",
         globals: Mapping[str, Any] | None = None,
-        params: TemplateParams | InlineTemplate,
-        _create_csrf_token: Callable[..., str] = create_csrf_token,
+        params: InlineTemplate,
     ) -> Response:
         """
         Render the template and build the HTTP Response.
         """
         request = self.request
-        reg = request.registry
-        request.scope[reg.settings.csrf_token_name] = (
-            request.cookies.get(reg.settings.csrf_token_name) or _create_csrf_token()
-        )
-        if isinstance(params, InlineTemplate):
-            data = self.render_inline(params)
-        else:
-            data = self.render_template(template, **params)
+        if globals:
+            self.globals.update(globals)
+        data = self.render_template(params)
         resp = Response(
             data, status_code=status_code, headers={"Content-Type": content_type}
         )
         resp.set_cookie(
-            reg.settings.csrf_token_name,
-            request.scope[reg.settings.csrf_token_name],
+            request.csrf_token.name,
+            request.csrf_token.value,
             secure=request.url.scheme == "https",
             samesite="strict",
             max_age=60 * 15,
@@ -71,34 +65,7 @@ class AbstractTemplateRenderer(abc.ABC):
         return resp
 
     @abc.abstractmethod
-    def render_template(
-        self,
-        template: str,
-        *,
-        globals: Mapping[str, Any] | None = None,
-        **params: Any,
-    ) -> str:
-        """
-        Render the given template with the given params.
-
-        While rendering templates, the globals parameter is keps by the instantiated
-        renderer and sent to every rendering made by the request.
-        This is used by the pydantic form method that will render other templates
-        for the request.
-        In traditional frameworks, only one template is rendered containing the whole
-        pages. But, while rendering a pydantic form, every field is rendered in its
-        distinct template. The template renderer keep the globals and git it back
-        to every templates. This can be used to fillout options in a select without
-        performing an ajax request for example.
-
-        :param template: name of the template to render.
-        :param globals: some variable that will be passed to all rendered templates.
-        :param params: paramaters that are limited to the main rendered templates.
-        :return: The template rendering result.
-        """
-
-    @abc.abstractmethod
-    def render_inline(self, template: InlineTemplate) -> str:
+    def render_template(self, template: InlineTemplate) -> str:
         """
         Render an inline template.
 

fastlife/services/translations.py

@@ -117,6 +117,18 @@ class Localizer:
             ret = ret.format(**mapping)
         return ret
 
+    def npgettext(
+        self,
+        context: str,
+        singular: str,
+        plural: str,
+        n: int,
+        mapping: dict[str, str] | None = None,
+    ) -> str:
+        ret = self.global_translations.npgettext(context, singular, plural, n)
+        mapping_num = {"num": n, **(mapping or {})}
+        return ret.format(**mapping_num)
+
     def dnpgettext(
         self,
         domain: str,

fastlife/templates/__init__.py

@@ -2,11 +2,6 @@
 Utilities for rendering HTML templates for page and components as FastAPI dependencies.
 """
 
-from .binding import Template, template
 from .inline import InlineTemplate
 
-__all__ = [
-    "Template",
-    "template",
-    "InlineTemplate",
-]
+__all__ = ["InlineTemplate"]

fastlife/templates/inline.py

@@ -1,22 +1,26 @@
 """Inline templates."""
 
-from typing import ClassVar
+import inspect
+from collections.abc import Callable
+from typing import Any, get_args
 
-from pydantic import BaseModel
-from pydantic.config import ConfigDict
+from fastlife.domain.model.template import InlineTemplate
+from fastlife.shared_utils.infer import is_union
 
 
-class InlineTemplate(BaseModel):
-    """
-    Inline templates are used to encourage the location of behavior and the view typing.
+def is_inline_template_returned(endpoint: Callable[..., Any]) -> bool:
+    signature = inspect.signature(endpoint)
+    return_annotation = signature.return_annotation
 
-    Pages produce templates that are not reusable and don't need to be reusable
-    in there essence, they don't need to be in a component library.
-    They use a component lirary to stay small but contains a view logic
-    tighly coupled with the view and its code can stay in the same module of that view.
-    """
+    if isinstance(return_annotation, type) and issubclass(
+        return_annotation, InlineTemplate
+    ):
+        return True
 
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+    if is_union(return_annotation):
+        return any(
+            isinstance(arg, type) and issubclass(arg, InlineTemplate)
+            for arg in get_args(return_annotation)
+        )
 
-    template: ClassVar[str]
-    """The template string to render."""
+    return False