fastlifeweb 0.27.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

fastlife/adapters/xcomponent/pydantic_form/widget_factory/enum_builder.py

@@ -0,0 +1,49 @@
+"""Handle Enum type."""
+
+from collections.abc import Mapping
+from enum import Enum
+from typing import Any
+
+from pydantic.fields import FieldInfo
+
+from fastlife.adapters.xcomponent.pydantic_form.widget_factory.base import (
+    BaseWidgetBuilder,
+)
+from fastlife.adapters.xcomponent.pydantic_form.widgets.base import Widget
+from fastlife.adapters.xcomponent.pydantic_form.widgets.dropdown import DropDownWidget
+
+
+class EnumBuilder(BaseWidgetBuilder[Enum]):
+    """Builder for Enum."""
+
+    def accept(self, typ: type[Any], origin: type[Any] | None) -> bool:
+        """True for Enum."""
+        return issubclass(typ, Enum)
+
+    def build(
+        self,
+        *,
+        field_name: str,
+        field_type: type[Any],  # an enum subclass
+        field: FieldInfo | None,
+        value: Enum | None,  # str | int | float,
+        form_errors: Mapping[str, Any],
+        removable: bool,
+    ) -> Widget[Enum]:
+        """Build the widget."""
+        options = [(item.name, item.value) for item in field_type]  # type: ignore
+        return DropDownWidget(
+            name=field_name,
+            options=options,  # type: ignore
+            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.factory.token,
+            value=str(value),
+            error=form_errors.get(field_name),
+        )

fastlife/adapters/xcomponent/pydantic_form/widget_factory/factory.py

@@ -0,0 +1,188 @@
+"""
+Create markup for pydantic forms.
+"""
+
+import secrets
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, get_origin
+
+from markupsafe import Markup
+from pydantic.fields import FieldInfo
+
+from fastlife.adapters.xcomponent.pydantic_form.widgets.base import CustomWidget, Widget
+from fastlife.domain.model.form import FormModel
+from fastlife.domain.model.template import XTemplate
+
+if TYPE_CHECKING:
+    from fastlife.service.templates import AbstractTemplateRenderer
+
+from .base import BaseWidgetBuilder
+from .bool_builder import BoolBuilder
+from .emailstr_builder import EmailStrBuilder
+from .enum_builder import EnumBuilder
+from .literal_builder import LiteralBuilder
+from .model_builder import ModelBuilder
+from .secretstr_builder import SecretStrBuilder
+from .sequence_builder import SequenceBuilder
+from .set_builder import SetBuilder
+from .simpletype_builder import SimpleTypeBuilder
+from .union_builder import UnionBuilder
+
+
+class OptionalFatalError(XTemplate):
+    template = """
+    <>
+      {
+        if message {
+            <FatalError message={message} />
+        }
+      }
+    </>
+    """
+    message: str
+
+
+class WidgetFactory:
+    """
+    Form builder for pydantic model.
+
+    :param renderer: template engine to render widget.
+    :param token: reuse a token.
+    """
+
+    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]] = [
+            # Order is super important here
+            # starts by the union type
+            UnionBuilder(self),
+            # and to other types that have an origin
+            SetBuilder(self),
+            LiteralBuilder(self),
+            SequenceBuilder(self),
+            # from this part, order does not really matter
+            ModelBuilder(self),
+            BoolBuilder(self),
+            EnumBuilder(self),
+            EmailStrBuilder(self),
+            SecretStrBuilder(self),
+            # we keep simple types, str, int at the end
+            SimpleTypeBuilder(self),
+        ]
+
+    def get_markup(
+        self,
+        model: FormModel[Any],
+        *,
+        removable: bool = False,
+        field: FieldInfo | None = None,
+    ) -> Markup:
+        """
+        Get the markup for the given model.
+
+        :param model: the model to build the html markup.
+        :param removable: Include a button to remove the model in the markup.
+        :param field: only build the markup of this field is not None.
+        """
+        ret = Markup()
+        if model.fatal_error:
+            ret += Markup(
+                self.renderer.render_template(
+                    OptionalFatalError(message=model.fatal_error)
+                )
+            )
+        ret += Markup(
+            self.get_widget(
+                model.model.__class__,
+                model.form_data,
+                model.errors,
+                prefix=model.prefix,
+                removable=removable,
+                field=field,
+            ).to_html(self.renderer)
+        )
+        return ret
+
+    def get_widget(
+        self,
+        base: type[Any],
+        form_data: Mapping[str, Any],
+        form_errors: Mapping[str, Any],
+        *,
+        prefix: str,
+        removable: bool,
+        field: FieldInfo | None = None,
+    ) -> Widget[Any]:
+        """
+        build the widget for the given type and return it.
+        :param base: the type to build, it has to be a builtin or a Pydantic model.
+        :param form_data: form values to render.
+        :param form_errors: form errors to render.
+        """
+        return self.build(
+            base,
+            value=form_data.get(prefix, {}),
+            form_errors=form_errors,
+            name=prefix,
+            removable=removable,
+            field=field,
+        )
+
+    def build(
+        self,
+        typ: type[Any],
+        *,
+        name: str = "",
+        value: Any,
+        removable: bool,
+        form_errors: Mapping[str, Any],
+        field: FieldInfo | None = None,
+    ) -> Widget[Any]:
+        """
+        build widget tree for the given type.
+        This function is recurive and shoud not be used directly.
+        The type is a composite, it can be pydantic model, builtin, list or unions.
+
+        The {meth}`WidgetFactory.get_widget` or {meth}`WidgetFactory.get_markup`
+        should be used.
+
+        :param typ: the type to build, it has to be a builtin or a Pydantic model.
+        :param name: name of the widget to build.
+        :param value: value for the widget.
+        :param removable: True if it has to include a remove button.
+        :param form_errors: errors in the form.
+        :param field: field information used to customize the widget.
+        """
+        if field and field.metadata:
+            for widget in field.metadata:
+                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:
+            if builder.accept(typ, type_origin):
+                return builder.build(
+                    field_name=name,
+                    field_type=typ,
+                    field=field,
+                    value=value,
+                    form_errors=form_errors,
+                    removable=removable,
+                )
+
+        raise NotImplementedError(f"{typ} not implemented")  # coverage: ignore

fastlife/adapters/xcomponent/pydantic_form/widget_factory/literal_builder.py

@@ -0,0 +1,55 @@
+"""Handle Literal type."""
+
+from collections.abc import Mapping
+from typing import Any, Literal
+
+from pydantic.fields import FieldInfo
+
+from fastlife.adapters.xcomponent.pydantic_form.widget_factory.base import (
+    BaseWidgetBuilder,
+)
+from fastlife.adapters.xcomponent.pydantic_form.widgets.dropdown import DropDownWidget
+from fastlife.adapters.xcomponent.pydantic_form.widgets.hidden import HiddenWidget
+from fastlife.domain.model.types import AnyLiteral
+
+
+class LiteralBuilder(BaseWidgetBuilder[AnyLiteral]):
+    """Builder for Literal."""
+
+    def accept(self, typ: type[Any], origin: type[Any] | None) -> bool:
+        """True for Literal."""
+        return origin is Literal
+
+    def build(
+        self,
+        *,
+        field_name: str,
+        field_type: type[Any],  # a literal actually
+        field: FieldInfo | None,
+        value: AnyLiteral | None,
+        form_errors: Mapping[str, Any],
+        removable: bool,
+    ) -> HiddenWidget | DropDownWidget:
+        """Build the widget."""
+        choices: list[str] = field_type.__args__  # type: ignore
+        if len(choices) == 1:
+            return HiddenWidget(
+                name=field_name,
+                value=choices[0],
+                token=self.factory.token,
+            )
+        return DropDownWidget(
+            name=field_name,
+            options=choices,  # type: ignore
+            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.factory.token,
+            value=str(value),
+            error=form_errors.get(field_name),
+        )

fastlife/adapters/xcomponent/pydantic_form/widget_factory/model_builder.py

@@ -0,0 +1,66 @@
+"""Handle Pydantic BaseModel type."""
+
+from collections.abc import Mapping
+from typing import Any
+
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+from fastlife.adapters.xcomponent.pydantic_form.widget_factory.base import (
+    BaseWidgetBuilder,
+)
+from fastlife.adapters.xcomponent.pydantic_form.widgets.base import Widget
+from fastlife.adapters.xcomponent.pydantic_form.widgets.model import ModelWidget
+
+
+class ModelBuilder(BaseWidgetBuilder[Mapping[str, Any]]):
+    """Builder for Pydantic BaseModel values."""
+
+    def accept(self, typ: type[Any], origin: type[Any] | None) -> bool:
+        """True for Pydantic BaseModel."""
+        return issubclass(typ, BaseModel)
+
+    def build(
+        self,
+        *,
+        field_name: str,
+        field_type: type[BaseModel],
+        field: FieldInfo | None,
+        value: Mapping[str, Any] | None,
+        form_errors: Mapping[str, Any],
+        removable: bool,
+    ) -> Widget[Any]:
+        """Build the widget."""
+        value = value or {}
+        ret: dict[str, Any] = {}
+        for key, child_field in field_type.model_fields.items():
+            child_key = f"{field_name}.{key}" if field_name else key
+            if child_field.exclude:
+                continue
+            if child_field.annotation is None:
+                raise ValueError(  # coverage: ignore
+                    f"Missing annotation for {child_field} in {child_key}"
+                )
+            ret[key] = self.factory.build(
+                child_field.annotation,
+                name=child_key,
+                field=child_field,
+                value=value.get(key),
+                form_errors=form_errors,
+                removable=False,
+            )
+        return ModelWidget[Any](
+            name=field_name,
+            value=list(ret.values()),
+            removable=removable,
+            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
+                if field and field.json_schema_extra
+                else None
+            ),
+            token=self.factory.token,
+            error=form_errors.get(field_name),
+            nested=field is not None,
+        )

fastlife/adapters/xcomponent/pydantic_form/widget_factory/secretstr_builder.py

@@ -0,0 +1,48 @@
+"""Handle Pydantic SecretStr type."""
+
+from collections.abc import Mapping
+from typing import Any
+
+from pydantic import SecretStr
+from pydantic.fields import FieldInfo
+
+from fastlife.adapters.xcomponent.pydantic_form.widget_factory.base import (
+    BaseWidgetBuilder,
+)
+from fastlife.adapters.xcomponent.pydantic_form.widgets.base import Widget
+from fastlife.adapters.xcomponent.pydantic_form.widgets.text import PasswordWidget
+
+
+class SecretStrBuilder(BaseWidgetBuilder[SecretStr]):
+    """Builder for Pydantic SecretStr."""
+
+    def accept(self, typ: type[Any], origin: type[Any] | None) -> bool:
+        """True for Pydantic SecretStr."""
+        return issubclass(typ, SecretStr)
+
+    def build(
+        self,
+        *,
+        field_name: str,
+        field_type: type[Any],
+        field: FieldInfo | None,
+        value: SecretStr | None,
+        form_errors: Mapping[str, Any],
+        removable: bool,
+    ) -> Widget[SecretStr]:
+        """Build the widget."""
+        return PasswordWidget(
+            name=field_name,
+            placeholder=str(field.examples[0]) if field and field.examples else None,
+            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.factory.token,
+            error=form_errors.get(field_name),
+            new_password="new-password" in field.metadata if field else False,
+        )

fastlife/adapters/xcomponent/pydantic_form/widget_factory/sequence_builder.py

@@ -0,0 +1,60 @@
+"""Handle Sequence type."""
+
+from collections.abc import Mapping, MutableSequence, Sequence
+from typing import Any
+
+from pydantic.fields import FieldInfo
+
+from fastlife.adapters.xcomponent.pydantic_form.widget_factory.base import (
+    BaseWidgetBuilder,
+)
+from fastlife.adapters.xcomponent.pydantic_form.widgets.base import Widget
+from fastlife.adapters.xcomponent.pydantic_form.widgets.sequence import SequenceWidget
+
+
+class SequenceBuilder(BaseWidgetBuilder[Sequence[Any]]):
+    """Builder for Sequence values."""
+
+    def accept(self, typ: type[Any], origin: type[Any] | None) -> bool:
+        """True for Sequence, MutableSequence or list"""
+        return origin is Sequence or origin is MutableSequence or origin is list
+
+    def build(
+        self,
+        *,
+        field_name: str,
+        field_type: type[Any],
+        field: FieldInfo | None,
+        value: Sequence[Any] | None,
+        form_errors: Mapping[str, Any],
+        removable: bool,
+    ) -> Widget[Sequence[Any]]:
+        """Build the widget."""
+        typ = field_type.__args__[0]  # type: ignore
+        value = value or []
+        items: Sequence[Any] = [
+            self.factory.build(
+                typ,  # type: ignore
+                name=f"{field_name}.{idx}",
+                value=v,
+                field=field,
+                form_errors=form_errors,
+                removable=True,
+            )
+            for idx, v in enumerate(value)
+        ]
+        return SequenceWidget[Any](
+            name=field_name,
+            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
+            ),
+            value=items,
+            item_type=typ,  # type: ignore
+            token=self.factory.token,
+            removable=removable,
+            error=form_errors.get(field_name),
+        )

fastlife/adapters/xcomponent/pydantic_form/widget_factory/set_builder.py

@@ -0,0 +1,85 @@
+"""Handle Set type."""
+
+from collections.abc import Mapping
+from enum import Enum
+from typing import Any, Literal, get_origin
+
+from pydantic.fields import FieldInfo
+
+from fastlife.adapters.xcomponent.pydantic_form.widget_factory.base import (
+    BaseWidgetBuilder,
+)
+from fastlife.adapters.xcomponent.pydantic_form.widgets.base import Widget
+from fastlife.adapters.xcomponent.pydantic_form.widgets.checklist import (
+    Checkable,
+    ChecklistWidget,
+)
+
+
+class SetBuilder(BaseWidgetBuilder[set[Any]]):
+    """Builder for Set."""
+
+    def accept(self, typ: type[Any], origin: type[Any] | None) -> bool:
+        """True for Set"""
+        return origin is set
+
+    def build(
+        self,
+        *,
+        field_name: str,
+        field_type: type[Any],
+        field: FieldInfo | None,
+        value: set[Any] | None,
+        form_errors: Mapping[str, Any],
+        removable: bool,
+    ) -> Widget[Any]:
+        """Build the widget."""
+        choice_wrapper = field_type.__args__[0]
+        choices = []
+        choice_wrapper_origin = get_origin(choice_wrapper)
+        if choice_wrapper_origin:
+            if choice_wrapper_origin is Literal:
+                litchoice: list[str] = choice_wrapper.__args__  # type: ignore
+                choices = [
+                    Checkable(
+                        label=c,
+                        value=c,
+                        checked=c in value if value else False,  # type: ignore
+                        name=field_name,
+                        token=self.factory.token,
+                        error=form_errors.get(f"{field_name}-{c}"),
+                    )
+                    for c in litchoice
+                ]
+
+            else:
+                raise NotImplementedError  # coverage: ignore
+        elif issubclass(choice_wrapper, Enum):
+            choices = [
+                Checkable(
+                    label=e.value,
+                    value=e.name,
+                    checked=e.name in value if value else False,  # type: ignore
+                    name=field_name,
+                    token=self.factory.token,
+                    error=form_errors.get(f"{field_name}-{e.name}"),
+                )
+                for e in choice_wrapper
+            ]
+        else:
+            raise NotImplementedError  # coverage: ignore
+
+        return ChecklistWidget(
+            name=field_name,
+            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.factory.token,
+            value=choices,
+            removable=removable,
+            error=form_errors.get(field_name),
+        )

fastlife/adapters/xcomponent/pydantic_form/widget_factory/simpletype_builder.py

@@ -0,0 +1,48 @@
+"""Handle simple types (str, int, float, ...)."""
+
+from collections.abc import Mapping
+from typing import Any
+
+from pydantic.fields import FieldInfo
+
+from fastlife.adapters.xcomponent.pydantic_form.widget_factory.base import (
+    BaseWidgetBuilder,
+)
+from fastlife.adapters.xcomponent.pydantic_form.widgets.base import Widget
+from fastlife.adapters.xcomponent.pydantic_form.widgets.text import TextWidget
+from fastlife.domain.model.types import Builtins
+
+
+class SimpleTypeBuilder(BaseWidgetBuilder[Builtins]):
+    """Builder for simple types."""
+
+    def accept(self, typ: type[Any], origin: type[Any] | None) -> bool:
+        """True for simple types: int, str, float, Decimal, UUID"""
+        return issubclass(typ, Builtins)
+
+    def build(
+        self,
+        *,
+        field_name: str,
+        field_type: type[Any],
+        field: FieldInfo | None,
+        value: Builtins | None,
+        form_errors: Mapping[str, Any],
+        removable: bool,
+    ) -> Widget[Builtins]:
+        """Build the widget."""
+        return TextWidget(
+            name=field_name,
+            placeholder=str(field.examples[0]) if field and field.examples else None,
+            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
+            ),
+            removable=removable,
+            token=self.factory.token,
+            value=str(value) if value else "",
+            error=form_errors.get(field_name),
+        )

fastlife/adapters/xcomponent/pydantic_form/widget_factory/union_builder.py

@@ -0,0 +1,92 @@
+"""Handle Union type."""
+
+from collections.abc import Mapping
+from types import NoneType
+from typing import Any
+
+from pydantic import ValidationError
+from pydantic.fields import FieldInfo
+
+from fastlife.adapters.xcomponent.pydantic_form.widget_factory.base import (
+    BaseWidgetBuilder,
+)
+from fastlife.adapters.xcomponent.pydantic_form.widgets.base import Widget
+from fastlife.adapters.xcomponent.pydantic_form.widgets.union import UnionWidget
+from fastlife.shared_utils.infer import is_complex_type, is_union
+
+
+class UnionBuilder(BaseWidgetBuilder[Any]):
+    """Builder for Union."""
+
+    def accept(self, typ: type[Any], origin: type[Any] | None) -> bool:
+        """True for unions Union[A,B], A | B or event Optional[A], A | None"""
+        return is_union(typ)
+
+    def build(
+        self,
+        *,
+        field_name: str,
+        field_type: type[Any],
+        field: FieldInfo | None,
+        value: Any | None,
+        form_errors: Mapping[str, Any],
+        removable: bool,
+    ) -> Widget[Any]:
+        """Build the widget."""
+        types: list[type[Any]] = []
+        # required = True
+        for typ in field_type.__args__:  # type: ignore
+            if typ is NoneType:
+                # required = False
+                continue
+            types.append(typ)  # type: ignore
+
+        if (
+            not removable
+            and len(types) == 1
+            # if the optional type is a complex type,
+            and not is_complex_type(types[0])
+        ):
+            return self.factory.build(  # coverage: ignore
+                types[0],
+                name=field_name,
+                field=field,
+                value=value,
+                form_errors=form_errors,
+                removable=False,
+            )
+        child = None
+        if value:
+            for typ in types:
+                try:
+                    typ(**value)
+                except ValidationError:
+                    pass
+                else:
+                    child = self.factory.build(
+                        typ,
+                        name=field_name,
+                        field=field,
+                        value=value,
+                        form_errors=form_errors,
+                        removable=False,
+                    )
+
+        widget = UnionWidget[Any](
+            name=field_name,
+            # we assume those types are BaseModel
+            value=child,
+            children_types=types,  # type: ignore
+            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.factory.token,
+            removable=removable,
+            error=form_errors.get(field_name),
+        )
+
+        return widget