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

fastlife/adapters/xcomponent/pydantic_form/widgets/__init__.py

@@ -0,0 +1 @@
+"""HTML Form generation using widgets."""

fastlife/adapters/xcomponent/pydantic_form/widgets/base.py

@@ -0,0 +1,140 @@
+"""Widget base class."""
+
+import secrets
+from collections.abc import Mapping
+from typing import Any, Generic, Self, TypeVar
+
+from markupsafe import Markup
+from pydantic import Field, model_validator
+
+from fastlife.domain.model.template import XTemplate
+from fastlife.service.templates import AbstractTemplateRenderer
+from fastlife.shared_utils.infer import is_union
+
+T = TypeVar("T")
+
+
+def get_title(typ: type[Any]) -> str:
+    return getattr(
+        getattr(typ, "__meta__", None),
+        "title",
+        getattr(typ, "__name__", ""),
+    )
+
+
+class Widget(XTemplate, Generic[T]):
+    """
+    Base class for widget of pydantic fields.
+
+    :param name: field name.
+    :param value: field value.
+    :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.
+    """
+
+    name: str
+    "variable name, nested variables have dots."
+    id: str = Field(default="")
+    "variable name, nested variables have dots."
+    value: T | None = Field(default=None)
+    """Value of the field."""
+    title: str = Field(default="")
+    "Human title for the widget."
+    hint: str | None = Field(default=None)
+    "A help message for the the widget."
+
+    error: str | None = Field(default=None)
+    "Error message."
+
+    aria_label: str | None = Field(default=None)
+    "Non visible text alternative."
+    token: str = Field(default="")
+    "Unique token to ensure id are unique in the DOM."
+    removable: bool = Field(default=False)
+    "Indicate that the widget is removable from the dom."
+
+    @model_validator(mode="after")
+    def fill_props(self) -> Self:
+        self.title = self.title or self.name.split(".")[-1]
+        self.token = self.token or secrets.token_urlsafe(4).replace("_", "-")
+        self.id = self.id or f"{self.name}-{self.token}".replace("_", "-").replace(
+            ".", "-"
+        )
+        return self
+
+    def to_html(self, renderer: AbstractTemplateRenderer) -> Markup:
+        """Return the html version."""
+        return Markup(renderer.render_template(self))
+
+
+def _get_fullname(typ: type[Any]) -> str:
+    if is_union(typ):
+        typs = [_get_fullname(t) for t in typ.__args__]  # type: ignore
+        return "|".join(typs)  # type: ignore
+    return f"{typ.__module__}:{typ.__name__}"
+
+
+TWidget = TypeVar("TWidget", bound=Widget[Any])
+
+
+class CustomWidget(Generic[TWidget]):
+    typ: type[Any]
+
+    def __init__(self, typ: type[TWidget]) -> None:
+        self.typ = typ
+
+
+class TypeWrapper:
+    """
+    Wrap children types for union type.
+
+    :param typ: Wrapped type.
+    :param route_prefix: route prefix used for ajax query to build type.
+    :param name: name of the field wrapped.
+    :param token: unique token to render unique id.
+    :param title: title to display.
+
+    """
+
+    def __init__(
+        self,
+        typ: type[Any],
+        route_prefix: str,
+        name: str,
+        token: str,
+        title: str | None = None,
+    ):
+        self.typ = typ
+        self.route_prefix = route_prefix
+        self.name = name
+        self.title = title or get_title(typ)
+        self.token = token
+
+    @property
+    def fullname(self) -> str:
+        """Full name for the type."""
+        return _get_fullname(self.typ)
+
+    @property
+    def id(self) -> str:
+        """Unique id to inject in the DOM."""
+        name = self.name.replace("_", "-").replace(".", "-").replace(":", "-")
+        typ = self.typ.__name__.replace("_", "-")
+        return f"{name}-{typ}-{self.token}"
+
+    @property
+    def params(self) -> Mapping[str, str]:
+        """Params for the widget to render."""
+        return {"name": self.name, "token": self.token, "title": self.title}
+
+    @property
+    def url(self) -> str:
+        """Url to fetch the widget."""
+        ret = f"{self.route_prefix}/pydantic-form/widgets/{self.fullname}?format=xcomponent"
+        return ret

fastlife/adapters/xcomponent/pydantic_form/widgets/boolean.py

@@ -0,0 +1,25 @@
+"""
+Widget for field of type bool.
+"""
+
+from .base import Widget
+
+
+class BooleanWidget(Widget[bool]):
+    """
+    Widget for field of type bool.
+    """
+
+    template = """
+    <Widget widget_id={id} removable={removable}>
+      <div class="pt-4">
+        <div class="flex items-center">
+         <Checkbox name={name} id={id} checked={value} value="1" />
+         <Label for={id} class="ms-2 text-base text-neutral-900 dark:text-white">
+            {globals.gettext(title)}
+          </Label>
+        </div>
+       <OptionalErrorText text={error} />
+      </div>
+    </Widget>
+    """

fastlife/adapters/xcomponent/pydantic_form/widgets/checklist.py

@@ -0,0 +1,75 @@
+"""
+Widget for field of type Set.
+"""
+
+from collections.abc import Sequence
+from typing import Any, Self
+
+from pydantic import BaseModel, Field, model_validator
+
+from fastlife.adapters.xcomponent.catalog import catalog
+
+from .base import Widget
+
+
+class Checkable(BaseModel):
+    """A checkable field from a checklist."""
+
+    label: str
+    name: str
+    value: str
+    token: str
+    checked: bool
+    error: str | None = Field(default=None)
+
+    id: str | None = Field(default=None)
+    field_name: str | None = Field(default=None)
+
+    @model_validator(mode="after")
+    def fill_props(self) -> Self:
+        self.id = f"{self.name}-{self.value}-{self.token}".replace(".", "-")
+        self.field_name = f"{self.name}[]"
+        return self
+
+
+@catalog.component
+def PydanticFormChecklistItem(value: Checkable, globals: Any) -> str:
+    return """
+    <div class="flex items-center mb-4">
+        <Checkbox name={value.field_name} type="checkbox"
+            id={value.id}
+            value={value.value}
+            checked={value.checked} />
+        <Label for={value.id}
+            class="ms-2 text-base text-neutral-900 dark:text-white">
+            {globals.gettext(value.label)}
+        </Label>
+        <OptionalErrorText text={value.error} />
+    </div>
+    """
+
+
+class ChecklistWidget(Widget[Sequence[Checkable]]):
+    """
+    Widget for field of type Set.
+    """
+
+    template = """
+    <Widget widget_id={id} removable={removable}>
+      <div class="pt-4">
+        <Details>
+          <Summary id={id + '-summary'}>
+            <H3 class={globals.H3_SUMMARY_CLASS}>{globals.gettext(title)}</H3>
+            <OptionalErrorText text={error} />
+          </Summary>
+          <div>
+            {
+              for v in value {
+                <PydanticFormChecklistItem value={v} />
+              }
+            }
+          </div>
+        </Details>
+      </div>
+    </Widget>
+    """

fastlife/adapters/xcomponent/pydantic_form/widgets/dropdown.py

@@ -0,0 +1,72 @@
+"""
+Widget for field of type Enum or Literal.
+"""
+
+from collections.abc import Sequence
+
+from pydantic import Field, field_validator
+from typing_extensions import TypedDict
+
+from fastlife.adapters.xcomponent.catalog import catalog
+
+from .base import Widget
+
+OptionItem = str | int
+
+
+class Option(TypedDict):
+    value: OptionItem
+    text: OptionItem
+
+
+@catalog.component
+def DropDownWidgetOption(id: str, opt: Option) -> str:
+    return """
+    <Option
+        value={opt.value}
+        id={id + "-" + opt.value.replace(" ", " -")}
+        selected={value and value == opt.value}
+        >
+      {globals.gettext(opt.text)}
+    </Option>
+    """
+
+
+class DropDownWidget(Widget[str]):
+    """
+    Widget for field of type Enum or Literal.
+    """
+
+    template = """
+    <Widget widget_id={id} removable={removable}>
+      <div class="pt-4">
+        <Label for={id}>{ globals.gettext(title) }</Label>
+        <Select name={name} id={id}>
+          {
+            for opt in options  {
+              <DropDownWidgetOption id={id} opt={opt} value={value}/>
+            }
+          }
+        </Select>
+        <OptionalErrorText text={error} />
+        <Hint text={hint} />
+      </div>
+    </Widget>
+    """
+
+    options: list[Option] = Field(default_factory=list)
+
+    @field_validator("options", mode="before")
+    @classmethod
+    def validate_options(
+        cls, options: Sequence[OptionItem | tuple[OptionItem, OptionItem]] | None
+    ) -> Sequence[Option]:
+        if not options:
+            return []
+        ret: list[Option] = []
+        for opt in options:
+            if isinstance(opt, tuple):
+                ret.append({"value": opt[0], "text": opt[1]})
+            else:
+                ret.append({"value": opt, "text": opt})
+        return ret

fastlife/adapters/xcomponent/pydantic_form/widgets/hidden.py

@@ -0,0 +1,25 @@
+"""Hidden fields"""
+
+from fastlife.domain.model.types import Builtins
+
+from .base import Widget
+
+
+class HiddenWidget(Widget[Builtins]):
+    '''
+    Widget to annotate to display a field as an hidden field.
+
+    ::
+        from pydantic import BaseModel
+        from fastlife.adapters.xcomponent.pydantic_form.widgets.base import CustomWidget
+        from fastlife.adapters.xcomponent.pydantic_form.widgets.hidden import HiddenWidget
+
+        class MyForm(BaseModel):
+            id: Annotated[str, CustomWidget(HiddenWidget)] = Field(...)
+            """Identifier in the database."""
+
+    '''
+
+    template = """
+    <Hidden name={name} value={value} id={id} />
+    """

fastlife/adapters/xcomponent/pydantic_form/widgets/mfa_code.py

@@ -0,0 +1,25 @@
+from pydantic import Field
+
+from .base import Widget
+
+
+class MFACodeWidget(Widget[str]):
+    """
+    Widget for MFA code such as TOTP token.
+    """
+
+    template = """
+    <Widget widget_id={id} removable={removable}>
+      <div class="pt-4">
+        <Label for={id}>{ globals.gettext(title) }</Label>
+        <OptionalErrorText text={error} />
+        <Input name={name} id={id} inputmode="numeric"
+            autocomplete="one-time-code" autofocus={autofocus}
+            aria-label={aria_label} placeholder={placeholder} />
+        <Hint text={hint} />
+      </div>
+    </Widget>
+    """
+
+    placeholder: str | None = Field(default=None)
+    autofocus: bool = Field(default=True)

fastlife/adapters/xcomponent/pydantic_form/widgets/model.py

@@ -0,0 +1,49 @@
+"""Pydantic models"""
+
+from collections.abc import Sequence
+
+from markupsafe import Markup
+from pydantic import Field
+
+from fastlife.service.templates import AbstractTemplateRenderer
+
+from .base import TWidget, Widget
+
+
+class ModelWidget(Widget[Sequence[TWidget]]):
+    template = """
+    <Widget widget_id={id} removable={removable}>
+    <div id={id} class={if nested {"m-4"}}>
+        {
+          if nested {
+            <Details>
+              <Summary id={id + '-summary'}>
+                <H3 class={globals.H3_SUMMARY_CLASS}>{ globals.gettext(title) }</H3>
+                <OptionalErrorText text={error} />
+              </Summary>
+              <div>
+                {
+                  for child in children_widgets {
+                    child
+                  }
+                }
+              </div>
+            </Details>
+          }
+          else {
+            for child in children_widgets {
+              child
+            }
+          }
+        }
+    </div>
+    </Widget>
+    """
+
+    nested: bool = Field(default=False)
+    children_widgets: list[str] | None = Field(default=None)
+
+    def to_html(self, renderer: AbstractTemplateRenderer) -> Markup:
+        """Return the html version."""
+        self.children_widgets = [child.to_html(renderer) for child in self.value or []]
+        return Markup(renderer.render_template(self))

fastlife/adapters/xcomponent/pydantic_form/widgets/sequence.py

@@ -0,0 +1,74 @@
+from collections.abc import Sequence
+from typing import Any
+
+from markupsafe import Markup
+from pydantic import Field
+
+from fastlife.service.templates import AbstractTemplateRenderer
+
+from .base import TWidget, TypeWrapper, Widget
+
+
+class SequenceWidget(Widget[Sequence[TWidget]]):
+    template = """
+    <Widget widget_id={id} removable={removable}>
+      <Details id={id}>
+        <Summary id={id + '-summary'}>
+          <H3 class={globals.H3_SUMMARY_CLASS}>{ globals.gettext(title) }</H3>
+          <OptionalErrorText text={error} />
+        </Summary>
+        <div>
+          <script>
+            // this function should be added once.
+            function getName(name, id) {
+              const el = document.getElementById(id + '-content');
+              const len = el.dataset.length;
+              el.dataset.length = parseInt(len) + 1;
+              return name + '.' + len;
+            }
+          </script>
+          <div id={id + "-content"} class="m-4"
+            data-length={len(children_widgets)}>
+            { let container_id = id + "-children-container" }
+            <div id={container_id}>
+              {
+                for child in children_widgets {
+                  child
+                }
+              }
+            </div>
+          </div>
+          <div>
+            { let container_id = "#" + id + "-children-container" }
+            { let add_id = id + "-add" }
+            { let vals = 'js:{"name": getName("' + wrapped_type.name + '", "' + id + '")'
+                + ', "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>
+    </Widget>
+    """
+
+    item_type: type[Any]
+    wrapped_type: TypeWrapper | None = Field(default=None)
+    children_widgets: list[str] | None = 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."""
+        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/xcomponent/pydantic_form/widgets/text.py

@@ -0,0 +1,121 @@
+from collections.abc import Sequence
+from typing import Any
+
+from pydantic import Field, SecretStr
+
+from fastlife.adapters.xcomponent.catalog import catalog
+from fastlife.domain.model.types import Builtins
+
+from .base import Widget
+
+
+@catalog.function
+def is_str(value: Any) -> bool:
+    return isinstance(value, str)
+
+
+class TextWidget(Widget[Builtins]):
+    """
+    Widget for text like field (email, ...).
+    """
+
+    template = """
+    <Widget widget_id={id} removable={removable}>
+      <div class="pt-4">
+        <Label for={id}>{globals.gettext(title)}</Label>
+        <OptionalErrorText text={error} />
+        <Input name={name} value={value} type={input_type} id={id}
+          aria-label={aria_label} placeholder={placeholder}
+         autocomplete={autocomplete} />
+        <Hint text={hint} />
+      </div>
+    </Widget>
+    """
+
+    input_type: str = Field(default="text")
+    """type attribute for the Input component."""
+    placeholder: str | None = Field(default=None)
+    """placeholder attribute for the Input component."""
+    autocomplete: str | None = Field(default=None)
+    """autocomplete attribute for the Input component."""
+
+
+class PasswordWidget(Widget[SecretStr]):
+    """
+    Widget for password fields.
+    """
+
+    template = """
+    <Widget widget_id={id} removable={removable}>
+      <div class="pt-4">
+        <Label for={id}>{globals.gettext(title)}</Label>
+        <OptionalErrorText text={error} />
+        <Password name={name} type={input_type} id={id}
+          autocomplete={
+            if new_password {
+              <>new-password</>
+            }
+            else {
+              <>current-password</>
+            }
+          }
+          aria-label={aria_label} placeholder={placeholder} />
+        <Hint text={hint} />
+      </div>
+    </Widget>
+    """
+
+    input_type: str = Field(default="password")
+    """type attribute for the Input component."""
+    placeholder: str | None = Field(default=None)
+    """placeholder attribute for the Input component."""
+    new_password: bool = Field(default=False)
+    """
+    Adapt autocomplete behavior for browsers to hint existing or generate password.
+    """
+
+
+class TextareaWidget(Widget[str | 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, CustomWidget(TextareaWidget)] = Field(...)
+        tags: Annotated[Sequence[str], CustomWidget(TextareaWidget)] = Field(
+            default_factory=list,
+            title="Tags",
+            description="One tag per line",
+        )
+
+        @field_validator("tags", mode="before")
+        def split(cls, s: Any) -> Sequence[str]:
+            return s.split() if s else []
+    ```
+    """
+
+    template = """
+    <Widget widget_id={id} removable={removable}>
+      <div class="pt-4">
+        <Label for={id}>{globals.gettext(title)}</Label>
+        <OptionalErrorText text={error} />
+        <Textarea name={name} id={id} aria-label={aria_label}>
+            {
+              if is_str(value) {
+                value
+              }
+              else {
+                for v in value {
+                  v + "\n"
+                }
+              }
+            }
+        </Textarea>
+        <Hint text={hint} />
+      </div>
+    </Widget>
+    """

fastlife/adapters/xcomponent/pydantic_form/widgets/union.py

@@ -0,0 +1,81 @@
+"""
+Widget for field of type Union.
+"""
+
+from collections.abc import Sequence
+from typing import Union
+
+from markupsafe import Markup
+from pydantic import BaseModel, Field
+
+from fastlife.service.templates import AbstractTemplateRenderer
+
+from .base import TWidget, TypeWrapper, Widget
+
+
+class UnionWidget(Widget[TWidget]):
+    """
+    Widget for union types.
+    """
+
+    template = """
+    <Widget widget_id={id} removable={removable}>
+      <div id={id}>
+        <Details>
+          <Summary id={id + '-union-summary'}>
+            <H3 class={globals.H3_SUMMARY_CLASS}>{ globals.gettext(title) }</H3>
+            <OptionalErrorText 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}
+                    id={typ.id}
+                    onclick={"document.getElementById('" + id + "-remove-btn').hidden=false"}
+                    class={globals.SECONDARY_BUTTON_CLASS}>{globals.gettext(typ.title)}</Button>
+                }
+              }
+            }
+          </div>
+          <Button type="button" id={id + '-remove-btn'} hx-target={'#' + id}
+            hx-vals={parent_type.params} hx-get={parent_type.url} hidden={not child}
+            class={globals.SECONDARY_BUTTON_CLASS}>
+            Remove
+          </Button>
+        </Details>
+      </div>
+    </Widget>
+    """
+
+    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."""
+        return [
+            TypeWrapper(typ, route_prefix, self.name, self.token)
+            for typ in self.children_types
+        ]
+
+    def to_html(self, renderer: "AbstractTemplateRenderer") -> Markup:
+        """Return the html version."""
+        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))