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

CHANGELOG.md

@@ -1,3 +1,20 @@
+## 0.22.0  - Released on 2024-11-23
+* Add a way to add fatal errors on form in order to display an error block.
+* The localizer can be called gettext in the depency in order to simple translation.
+* Expose the 99% of the usefull API in the main package.
+* Refactor all internal class to get a more hexagonal approach in order to reduce
+  circular dependencies.
+
+## 0.21.0  - Released on 2024-11-15
+* Make the InlineTemplate the only way to render views template.
+  * Breaking change: template args is not supported in Configutor.add_route.
+  * Breaking change: template args is not supported in @view_config.
+  * Breaking change: template and Template dedendencies have been removed.
+* Add new method in the configurator to register global vars for template:
+    {meth}`fastlife.config.configurator.GenericConfigurator.add_renderer_global`.
+* Add npgettext i18n helper method support.
+* Remove babel from dependency list (only a dev dependency).
+
 ## 0.20.1  - Released on 2024-11-09
 * Add a new class GenericRegistry in order to properly type custom Configurator / Registry / Settings
 * Using InlineTemplate, we can pass arbitrary types for pydantic form
@@ -41,7 +58,7 @@
 * Hotfix components to create tables
 
 ## 0.15.0  - Released on 2024-09-29
-* Add an {class}`fastlife.security.policy.AbstractSecurityPolicy` class
+* Add an {class}`fastlife.service.security_policy.AbstractSecurityPolicy` class
 * New method {meth}`fastlife.config.configurator.GenericConfigurator.set_security_policy`
 * Breaking change, the check_permission has been removed from the settings.
   to configure the permission policy, a security policy has to be implemented.

fastlife/__init__.py

@@ -3,40 +3,72 @@ from importlib import metadata
 __version__ = metadata.version("fastlifeweb")
 
 from fastapi import Response
+from fastapi.responses import RedirectResponse
 
+from .adapters.fastapi.form import form_model
+from .adapters.fastapi.localizer import Localizer
+from .adapters.fastapi.request import AnyRequest, Registry, Request, get_request
 from .config import (
     Configurator,
-    DefaultRegistry,
     GenericConfigurator,
-    GenericRegistry,
-    Settings,
     configure,
+    exception_handler,
     resource,
     resource_view,
     view_config,
 )
-from .request import GenericRequest, Registry, Request, get_request
+from .domain.model.form import FormModel
+from .domain.model.request import GenericRequest
+from .domain.model.security_policy import (
+    Allowed,
+    Denied,
+    Forbidden,
+    HasPermission,
+    Unauthenticated,
+    Unauthorized,
+)
+from .domain.model.template import JinjaXTemplate
 
 # from .request.form_data import model
-from .services.templates import TemplateParams
+from .service.registry import DefaultRegistry, GenericRegistry
+from .service.security_policy import AbstractSecurityPolicy, InsecurePolicy
+from .settings import Settings
 
 __all__ = [
     # Config
-    "configure",
     "GenericConfigurator",
-    "Configurator",
-    "DefaultRegistry",
     "GenericRegistry",
-    "TemplateParams",
+    "Registry",
     "Settings",
+    "configure",
     "view_config",
+    "exception_handler",
     "resource",
     "resource_view",
-    # Model
-    # "model",
-    "Request",
+    "Configurator",
+    "DefaultRegistry",
+    # Form
+    "FormModel",
+    "form_model",
+    # Request
     "GenericRequest",
+    "AnyRequest",
+    "Request",
     "get_request",
-    "Registry",
+    # Response
     "Response",
+    "RedirectResponse",
+    # Security
+    "AbstractSecurityPolicy",
+    "HasPermission",
+    "Unauthenticated",
+    "Allowed",
+    "Denied",
+    "Unauthorized",
+    "Forbidden",
+    "InsecurePolicy",
+    # Template
+    "JinjaXTemplate",
+    # i18n
+    "Localizer",
 ]

fastlife/adapters/__init__.py

@@ -1,3 +1,3 @@
 """
-Adapters are implementations of abstract classed defined in {mod}`fastlife.services`.
+Adapters are implementations of abstract classed defined in {mod}`fastlife.service`.
 """

fastlife/adapters/fastapi/__init__.py

@@ -0,0 +1,9 @@
+"""
+Adapters based on top of FastAPI.
+
+At the momdent, the code is highly coupled with FastAPI,
+some part of the code import fastapi directly for legacy reason,
+but it shouldn't.
+
+All FastAPI dependency should be contained in this module.
+"""

fastlife/adapters/fastapi/form.py

@@ -0,0 +1,26 @@
+"""HTTP Form serialization."""
+
+from collections.abc import Callable, Mapping
+from typing import Any
+
+from fastapi import Depends
+
+from fastlife.adapters.fastapi.form_data import MappingFormData
+from fastlife.adapters.fastapi.request import Registry
+from fastlife.domain.model.form import FormModel, T
+
+
+def form_model(
+    cls: type[T], name: str | None = None
+) -> Callable[[Mapping[str, Any]], FormModel[T]]:
+    """
+    Build a model, a class of type T based on Pydandic Base Model from a form payload.
+    """
+
+    def to_model(data: MappingFormData, registry: Registry) -> FormModel[T]:
+        prefix = name or registry.settings.form_data_model_prefix
+        if not data:
+            return FormModel[T].default(prefix, cls)
+        return FormModel[T].from_payload(prefix, cls, data)
+
+    return Depends(to_model)

fastlife/{request → adapters/fastapi}/form_data.py

@@ -10,7 +10,7 @@ from typing import (
 
 from fastapi import Depends
 
-from fastlife import Request
+from fastlife.adapters.fastapi.request import Request
 
 
 def unflatten_struct(

fastlife/{request → adapters/fastapi}/localizer.py

@@ -2,12 +2,14 @@ from typing import Annotated
 
 from fastapi import Depends
 
-from fastlife.request.request import Request
-from fastlife.services.translations import Localizer as RequestLocalizer
+from fastlife.adapters.fastapi.request import Request
+from fastlife.service.translations import Localizer as RequestLocalizer
 
 
 def get_localizer(request: Request) -> RequestLocalizer:
+    """Return the localizer for the given request."""
     return request.registry.localizer(request)
 
 
 Localizer = Annotated[RequestLocalizer, Depends(get_localizer)]
+"""Define a localizer"""

fastlife/adapters/fastapi/request.py

@@ -0,0 +1,33 @@
+"""HTTP Request representation in a python object."""
+
+from typing import Annotated, Any
+
+from fastapi import Request as FastAPIRequest
+from fastapi.params import Depends
+
+from fastlife.domain.model.request import GenericRequest
+from fastlife.service.registry import DefaultRegistry
+
+
+def get_request(request: FastAPIRequest) -> GenericRequest[Any]:
+    """Return the Fastlife Request object."""
+    return request  # type: ignore
+
+
+Request = Annotated[GenericRequest[DefaultRegistry], Depends(get_request)]
+"""A request that is associated to the default registry."""
+# FastAPI handle its Request objects using a lenient_issubclass,
+# basically a issubclass(Request), doe to the Generic[T], it does not work.
+
+
+AnyRequest = Annotated[GenericRequest[Any], Depends(get_request)]
+"""A request version that is associated to the any registry."""
+
+
+def get_registry(request: Request) -> DefaultRegistry:
+    """Return the Fastlife Registry object."""
+    return request.registry
+
+
+Registry = Annotated[DefaultRegistry, Depends(get_registry)]
+"""FastAPI dependency to access to the global registry."""

fastlife/{routing → adapters/fastapi/routing}/route.py

@@ -7,10 +7,10 @@ from fastapi.routing import APIRoute
 from starlette.requests import Request as StarletteRequest
 from starlette.responses import Response
 
-from fastlife.request.request import Request
+from fastlife.domain.model.request import GenericRequest
 
 if TYPE_CHECKING:
-    from fastlife.config.registry import DefaultRegistry  # coverage: ignore
+    from fastlife.service.registry import DefaultRegistry  # coverage: ignore
 
 
 class Route(APIRoute):
@@ -41,7 +41,7 @@ class Route(APIRoute):
         orig_route_handler = super().get_route_handler()
 
         async def route_handler(request: StarletteRequest) -> Response:
-            req = Request(self._registry, request)
+            req = GenericRequest(self._registry, request)
             return await orig_route_handler(req)
 
         return route_handler

fastlife/{routing → adapters/fastapi/routing}/router.py

@@ -9,7 +9,7 @@ from typing import Any
 
 from fastapi import APIRouter
 
-from fastlife.routing.route import Route
+from fastlife.adapters.fastapi.routing.route import Route
 
 
 class Router(APIRouter):

fastlife/adapters/itsdangerous/__init__.py

@@ -0,0 +1,3 @@
+from .session import SignedSessionSerializer
+
+__all__ = ["SignedSessionSerializer"]

fastlife/adapters/itsdangerous/session.py

@@ -0,0 +1,50 @@
+"""Serialize session."""
+
+import json
+from base64 import b64decode, b64encode
+from collections.abc import Mapping
+from typing import Any
+
+import itsdangerous
+
+from fastlife.middlewares.session.serializer import AbsractSessionSerializer
+
+
+class SignedSessionSerializer(AbsractSessionSerializer):
+    """
+    The default fastlife session serializer.
+
+    It's based on the itsdangerous package to sign the session with a secret key.
+
+    :param secret_key: a secret used to sign the session payload.
+
+    :param max_age: session lifetime in seconds.
+    """
+
+    def __init__(self, secret_key: str, max_age: int) -> None:
+        self.signer = itsdangerous.TimestampSigner(secret_key)
+        self.max_age = max_age
+
+    def serialize(self, data: Mapping[str, Any]) -> bytes:
+        """Serialize and sign the session."""
+        dump = json.dumps(data).encode("utf-8")
+        encoded = b64encode(dump)
+        signed = self.signer.sign(encoded)
+        return signed
+
+    def deserialize(self, data: bytes) -> tuple[Mapping[str, Any], bool]:
+        """Deserialize the session.
+
+        If the signature is incorect, the session restart from the begining.
+        No exception raised.
+        """
+        try:
+            data = self.signer.unsign(data, max_age=self.max_age)
+            # We can't deserialize something wrong since the serialize
+            # is signing the content.
+            # If the signature key is compromise and we have invalid payload,
+            # raising exceptions here is fine, it's dangerous afterall.
+            session = json.loads(b64decode(data))
+        except itsdangerous.BadSignature:
+            return {}, True
+        return session, False

fastlife/adapters/jinjax/jinjax_ext/inspectable_component.py

@@ -42,17 +42,17 @@ class InspectableComponent(Component):
     """
 
     __slots__ = (
-        "name",
-        "prefix",
-        "url_prefix",
-        "required",
-        "optional",
         "css",
         "js",
-        "path",
         "mtime",
-        "tmpl",
+        "name",
+        "optional",
+        "path",
+        "prefix",
+        "required",
         "source",
+        "tmpl",
+        "url_prefix",
     )
 
     def __init__(

fastlife/adapters/jinjax/jinjax_ext/jinjax_doc.py

@@ -14,7 +14,7 @@ from sphinx.roles import XRefRole
 from sphinx.util import relative_uri  # type: ignore
 
 from fastlife.adapters.jinjax.renderer import JinjaxEngine
-from fastlife.config.settings import Settings
+from fastlife.settings import Settings
 
 
 def create_ref_node(arg_type: str) -> nodes.Node:

fastlife/adapters/jinjax/renderer.py

@@ -4,7 +4,7 @@ Template rending based on JinjaX.
 
 import logging
 import textwrap
-from collections.abc import Mapping, MutableMapping, Sequence
+from collections.abc import Sequence
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -14,15 +14,15 @@ from markupsafe import Markup
 from pydantic.fields import FieldInfo
 
 from fastlife import Request
+from fastlife.adapters.fastapi.form import FormModel
+from fastlife.adapters.fastapi.localizer import get_localizer
 from fastlife.adapters.jinjax.widget_factory.factory import WidgetFactory
-from fastlife.request.form import FormModel
-from fastlife.request.localizer import get_localizer
-from fastlife.templates.inline import InlineTemplate
+from fastlife.domain.model.template import InlineTemplate
 
 if TYPE_CHECKING:
-    from fastlife.config.settings import Settings  # coverage: ignore
+    from fastlife.settings import Settings  # coverage: ignore
 
-from fastlife.services.templates import (
+from fastlife.service.templates import (
     AbstractTemplateRenderer,
     AbstractTemplateRendererFactory,
 )
@@ -66,58 +66,10 @@ class JinjaxRenderer(AbstractTemplateRenderer):
         super().__init__(request)
         self.catalog = catalog
         self.settings = request.registry.settings
-        self.globals: MutableMapping[str, Any] = {}
         self.translations = get_localizer(request)
+        self.globals["pydantic_form"] = self.pydantic_form
 
-    def build_globals(self) -> Mapping[str, Any]:
-        """
-        Build globals variables accessible in any templates.
-
-        * `request` is the {class}`current request <fastlife.request.request.Request>`
-        * `csrf_token` is used to build for {jinjax:component}`CsrfToken`.
-        """
-        settings = self.settings
-        ret = {
-            "request": self.request,
-            "csrf_token": {
-                "name": settings.csrf_token_name,
-                "value": self.request.scope.get(settings.csrf_token_name, ""),
-            },
-            "pydantic_form": self.pydantic_form,
-            "localizer": self.translations,
-            **self.globals,
-        }
-        return ret
-
-    def render_template(
-        self,
-        template: str,
-        *,
-        globals: Mapping[str, Any] | None = None,
-        **params: Any,
-    ) -> str:
-        """
-        Render the JinjaX component with the given parameter.
-
-        :param template: the template to render
-        :param globals: parameters that will be used by the JinjaX component and all its
-            child components without "props drilling".
-        :param params: parameters used to render the template.
-        """
-
-        template = template[: -len(self.settings.jinjax_file_ext) - 1]
-        if globals:
-            self.globals.update(globals)
-
-        self.catalog.jinja_env.install_gettext_translations(  # type: ignore
-            self.translations, newstyle=True
-        )
-
-        return self.catalog.render(  # type: ignore
-            template, __globals=self.build_globals(), **params
-        )
-
-    def render_inline(self, template: InlineTemplate) -> str:
+    def render_template(self, template: InlineTemplate) -> str:
         """
         Render the JinjaX component with the given parameter.
 
@@ -134,7 +86,7 @@ class JinjaxRenderer(AbstractTemplateRenderer):
         return self.catalog.render(
             template.__class__.__qualname__,
             __source=src,
-            __globals=self.build_globals(),
+            __globals=self.globals,
             **params,
         )
 

fastlife/adapters/jinjax/widget_factory/bool_builder.py

@@ -28,9 +28,9 @@ class BoolBuilder(BaseWidgetBuilder[bool]):
     ) -> BooleanWidget:
         """Build the widget."""
         return BooleanWidget(
-            field_name,
+            name=field_name,
             removable=removable,
-            title=field.title if field else "",
+            title=field.title or "" if field else "",
             hint=field.description if field else None,
             aria_label=(
                 field.json_schema_extra.get("aria_label")  # type:ignore

fastlife/adapters/jinjax/widget_factory/emailstr_builder.py

@@ -8,9 +8,10 @@ from pydantic.networks import EmailStr
 
 from fastlife.adapters.jinjax.widget_factory.base import BaseWidgetBuilder
 from fastlife.adapters.jinjax.widgets.text import TextWidget
+from fastlife.domain.model.types import Builtins
 
 
-class EmailStrBuilder(BaseWidgetBuilder[EmailStr]):
+class EmailStrBuilder(BaseWidgetBuilder[Builtins]):
     """Builder for Pydantic EmailStr."""
 
     def accept(self, typ: type[Any], origin: type[Any] | None) -> bool:
@@ -23,17 +24,17 @@ class EmailStrBuilder(BaseWidgetBuilder[EmailStr]):
         field_name: str,
         field_type: type[Any],
         field: FieldInfo | None,
-        value: EmailStr | None,
+        value: Builtins | None,
         form_errors: Mapping[str, Any],
         removable: bool,
     ) -> TextWidget:
         """Build the widget."""
         return TextWidget(
-            field_name,
+            name=field_name,
             input_type="email",
             placeholder=str(field.examples[0]) if field and field.examples else None,
             removable=removable,
-            title=field.title if field else "",
+            title=field.title or "" if field else "",
             hint=field.description if field else None,
             aria_label=(
                 field.json_schema_extra.get("aria_label")  # type:ignore

fastlife/adapters/jinjax/widget_factory/enum_builder.py

@@ -31,10 +31,10 @@ class EnumBuilder(BaseWidgetBuilder[Enum]):
         """Build the widget."""
         options = [(item.name, item.value) for item in field_type]  # type: ignore
         return DropDownWidget(
-            field_name,
+            name=field_name,
             options=options,  # type: ignore
             removable=removable,
-            title=field.title if field else "",
+            title=field.title or "" if field else "",
             hint=field.description if field else None,
             aria_label=(
                 field.json_schema_extra.get("aria_label")  # type:ignore

fastlife/adapters/jinjax/widget_factory/factory.py

@@ -4,15 +4,17 @@ Create markup for pydantic forms.
 
 import secrets
 from collections.abc import Mapping
-from inspect import isclass
-from typing import Any, cast, get_origin
+from typing import TYPE_CHECKING, Any, get_origin
 
 from markupsafe import Markup
 from pydantic.fields import FieldInfo
 
-from fastlife.adapters.jinjax.widgets.base import Widget
-from fastlife.request.form import FormModel
-from fastlife.services.templates import AbstractTemplateRenderer
+from fastlife.adapters.jinjax.widgets.base import CustomWidget, Widget
+from fastlife.domain.model.form import FormModel
+from fastlife.domain.model.template import JinjaXTemplate
+
+if TYPE_CHECKING:
+    from fastlife.service.templates import AbstractTemplateRenderer
 
 from .base import BaseWidgetBuilder
 from .bool_builder import BoolBuilder
@@ -27,6 +29,11 @@ from .simpletype_builder import SimpleTypeBuilder
 from .union_builder import UnionBuilder
 
 
+class FatalError(JinjaXTemplate):
+    template = """<pydantic_form.FatalError :message="message" />"""
+    message: str
+
+
 class WidgetFactory:
     """
     Form builder for pydantic model.
@@ -35,7 +42,7 @@ class WidgetFactory:
     :param token: reuse a token.
     """
 
-    def __init__(self, renderer: AbstractTemplateRenderer, token: str | None = None):
+    def __init__(self, renderer: "AbstractTemplateRenderer", token: str | None = None):
         self.renderer = renderer
         self.token = token or secrets.token_urlsafe(4).replace("_", "-")
         self.builders: list[BaseWidgetBuilder[Any]] = [
@@ -70,7 +77,10 @@ class WidgetFactory:
         :param removable: Include a button to remove the model in the markup.
         :param field: only build the markup of this field is not None.
         """
-        return self.get_widget(
+        ret = Markup()
+        if model.fatal_error:
+            ret += self.renderer.render_template(FatalError(message=model.fatal_error))
+        ret += self.get_widget(
             model.model.__class__,
             model.form_data,
             model.errors,
@@ -78,6 +88,7 @@ class WidgetFactory:
             removable=removable,
             field=field,
         ).to_html(self.renderer)
+        return ret
 
     def get_widget(
         self,
@@ -131,24 +142,22 @@ class WidgetFactory:
         """
         if field and field.metadata:
             for widget in field.metadata:
-                if isclass(widget) and issubclass(widget, Widget):
-                    return cast(
-                        Widget[Any],
-                        widget(
-                            name,
-                            value=value,
-                            removable=removable,
-                            title=field.title if field else "",
-                            hint=field.description if field else None,
-                            aria_label=(
-                                field.json_schema_extra.get("aria_label")  # type:ignore
-                                if field and field.json_schema_extra
-                                else None
-                            ),
-                            token=self.token,
-                            error=form_errors.get(name),
+                if isinstance(widget, CustomWidget):
+                    ret: Widget[Any] = widget.typ(
+                        name=name,
+                        value=value,
+                        removable=removable,
+                        title=field.title or "" if field else "",
+                        hint=field.description if field else None,
+                        aria_label=(
+                            field.json_schema_extra.get("aria_label")  # type:ignore
+                            if field and field.json_schema_extra
+                            else None
                         ),
+                        token=self.token,
+                        error=form_errors.get(name),
                     )
+                    return ret
 
         type_origin = get_origin(typ)
         for builder in self.builders:

fastlife/adapters/jinjax/widget_factory/literal_builder.py

@@ -8,9 +8,10 @@ from pydantic.fields import FieldInfo
 from fastlife.adapters.jinjax.widget_factory.base import BaseWidgetBuilder
 from fastlife.adapters.jinjax.widgets.dropdown import DropDownWidget
 from fastlife.adapters.jinjax.widgets.hidden import HiddenWidget
+from fastlife.domain.model.types import AnyLiteral
 
 
-class LiteralBuilder(BaseWidgetBuilder[str]):  # str|int|bool
+class LiteralBuilder(BaseWidgetBuilder[AnyLiteral]):
     """Builder for Literal."""
 
     def accept(self, typ: type[Any], origin: type[Any] | None) -> bool:
@@ -23,7 +24,7 @@ class LiteralBuilder(BaseWidgetBuilder[str]):  # str|int|bool
         field_name: str,
         field_type: type[Any],  # a literal actually
         field: FieldInfo | None,
-        value: str | None,
+        value: AnyLiteral | None,
         form_errors: Mapping[str, Any],
         removable: bool,
     ) -> HiddenWidget | DropDownWidget:
@@ -31,15 +32,15 @@ class LiteralBuilder(BaseWidgetBuilder[str]):  # str|int|bool
         choices: list[str] = field_type.__args__  # type: ignore
         if len(choices) == 1:
             return HiddenWidget(
-                field_name,
+                name=field_name,
                 value=choices[0],
                 token=self.factory.token,
             )
         return DropDownWidget(
-            field_name,
-            options=choices,
+            name=field_name,
+            options=choices,  # type: ignore
             removable=removable,
-            title=field.title if field else "",
+            title=field.title or "" if field else "",
             hint=field.description if field else None,
             aria_label=(
                 field.json_schema_extra.get("aria_label")  # type:ignore

fastlife/adapters/jinjax/widget_factory/model_builder.py

@@ -47,11 +47,11 @@ class ModelBuilder(BaseWidgetBuilder[Mapping[str, Any]]):
                 form_errors=form_errors,
                 removable=False,
             )
-        return ModelWidget(
-            field_name,
+        return ModelWidget[Any](
+            name=field_name,
             value=list(ret.values()),
             removable=removable,
-            title=field.title if field and field.title else "",
+            title=field.title or "" if field and field.title else "",
             hint=field.description if field else None,
             aria_label=(
                 field.json_schema_extra.get("aria_label")  # type:ignore