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

fastlife/adapters/jinjax/widget_factory/secretstr_builder.py

@@ -30,11 +30,11 @@ class SecretStrBuilder(BaseWidgetBuilder[SecretStr]):
     ) -> Widget[SecretStr]:
         """Build the widget."""
         return TextWidget(
-            field_name,
+            name=field_name,
             input_type="password",
             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/sequence_builder.py

@@ -41,9 +41,9 @@ class SequenceBuilder(BaseWidgetBuilder[Sequence[Any]]):
             )
             for idx, v in enumerate(value)
         ]
-        return SequenceWidget(
-            field_name,
-            title=field.title if field else "",
+        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

fastlife/adapters/jinjax/widget_factory/set_builder.py

@@ -65,8 +65,8 @@ class SetBuilder(BaseWidgetBuilder[set[Any]]):
             raise NotImplementedError  # coverage: ignore
 
         return ChecklistWidget(
-            field_name,
-            title=field.title if field else "",
+            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

fastlife/adapters/jinjax/widget_factory/simpletype_builder.py

@@ -1,23 +1,22 @@
 """Handle simple types (str, int, float, ...)."""
 
 from collections.abc import Mapping
-from decimal import Decimal
 from typing import Any
-from uuid import UUID
 
 from pydantic.fields import FieldInfo
 
 from fastlife.adapters.jinjax.widget_factory.base import BaseWidgetBuilder
 from fastlife.adapters.jinjax.widgets.base import Widget
 from fastlife.adapters.jinjax.widgets.text import TextWidget
+from fastlife.domain.model.types import Builtins
 
 
-class SimpleTypeBuilder(BaseWidgetBuilder[str | int | str | float | Decimal | UUID]):
+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, int | str | float | Decimal | UUID)
+        return issubclass(typ, Builtins)
 
     def build(
         self,
@@ -25,15 +24,15 @@ class SimpleTypeBuilder(BaseWidgetBuilder[str | int | str | float | Decimal | UU
         field_name: str,
         field_type: type[Any],
         field: FieldInfo | None,
-        value: int | str | float | Decimal | UUID | None,
+        value: Builtins | None,
         form_errors: Mapping[str, Any],
         removable: bool,
-    ) -> Widget[int | str | float | Decimal | UUID]:
+    ) -> Widget[Builtins]:
         """Build the widget."""
         return TextWidget(
-            field_name,
+            name=field_name,
             placeholder=str(field.examples[0]) if field and field.examples else None,
-            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/union_builder.py

@@ -70,12 +70,12 @@ class UnionBuilder(BaseWidgetBuilder[Any]):
                         removable=False,
                     )
 
-        widget = UnionWidget(
-            field_name,
+        widget = UnionWidget[Any](
+            name=field_name,
             # we assume those types are BaseModel
             value=child,
             children_types=types,  # type: ignore
-            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/widgets/base.py

@@ -1,13 +1,14 @@
 """Widget base class."""
 
-import abc
 import secrets
 from collections.abc import Mapping
-from typing import Any, Generic, TypeVar
+from typing import Any, Generic, Self, TypeVar
 
 from markupsafe import Markup
+from pydantic import Field, model_validator
 
-from fastlife.services.templates import AbstractTemplateRenderer
+from fastlife.domain.model.template import JinjaXTemplate
+from fastlife.service.templates import AbstractTemplateRenderer
 from fastlife.shared_utils.infer import is_union
 
 T = TypeVar("T")
@@ -21,7 +22,7 @@ def get_title(typ: type[Any]) -> str:
     )
 
 
-class Widget(abc.ABC, Generic[T]):
+class Widget(JinjaXTemplate, Generic[T]):
     """
     Base class for widget of pydantic fields.
 
@@ -39,48 +40,37 @@ class Widget(abc.ABC, Generic[T]):
 
     name: str
     "variable name, nested variables have dots."
-    value: T | None
+    id: str = Field(default="")
+    "variable name, nested variables have dots."
+    value: T | None = Field(default=None)
     """Value of the field."""
-    title: str
+    title: str = Field(default="")
     "Human title for the widget."
-    hint: str
+    hint: str | None = Field(default=None)
     "A help message for the the widget."
-    aria_label: str
+
+    error: str | None = Field(default=None)
+    "Error message."
+
+    aria_label: str | None = Field(default=None)
     "Non visible text alternative."
-    token: str
+    token: str = Field(default="")
     "unique token to ensure id are unique in the DOM."
-    removable: bool
+    removable: bool = Field(default=False)
     "Indicate that the widget is removable from the dom."
 
-    def __init__(
-        self,
-        name: str,
-        *,
-        value: T | None = None,
-        error: str | None = None,
-        title: str | None = None,
-        hint: str | None = None,
-        token: str | None = None,
-        aria_label: str | None = None,
-        removable: bool = False,
-    ):
-        self.name = name
-        self.value = value
-        self.error = error
-        self.title = title or name.split(".")[-1]
-        self.hint = hint or ""
-        self.aria_label = aria_label or ""
-        self.token = token or secrets.token_urlsafe(4).replace("_", "-")
-        self.removable = removable
-        self.id = f"{self.name}-{self.token}".replace("_", "-").replace(".", "-")
-
-    @abc.abstractmethod
-    def get_template(self) -> str:
-        """Get the widget component template."""
+    @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.get_template(), widget=self))
+        return Markup(renderer.render_template(self))
 
 
 def _get_fullname(typ: type[Any]) -> str:
@@ -90,6 +80,16 @@ def _get_fullname(typ: type[Any]) -> str:
     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.

fastlife/adapters/jinjax/widgets/boolean.py

@@ -8,39 +8,18 @@ from .base import Widget
 class BooleanWidget(Widget[bool]):
     """
     Widget for field of type bool.
-
-    :param name: field 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 removable: display a button to remove the widget for optional fields.
-    :param token: token used to get unique id on the form.
     """
 
-    def __init__(
-        self,
-        name: str,
-        *,
-        title: str | None,
-        hint: str | None = None,
-        aria_label: str | None = None,
-        value: bool = False,
-        error: str | None = None,
-        removable: bool = False,
-        token: str,
-    ) -> None:
-        super().__init__(
-            name,
-            title=title,
-            hint=hint,
-            aria_label=aria_label,
-            value=value,
-            error=error,
-            removable=removable,
-            token=token,
-        )
-
-    def get_template(self) -> str:
-        return "pydantic_form.Boolean.jinja"
+    template = """
+    <pydantic_form.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">
+            {{title|safe}}
+          </Label>
+        </div>
+       <pydantic_form.Error :text="error" />
+      </div>
+    </pydantic_form.Widget>
+    """

fastlife/adapters/jinjax/widgets/checklist.py

@@ -3,8 +3,9 @@ Widget for field of type Set.
 """
 
 from collections.abc import Sequence
+from typing import Self
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 
 from .base import Widget
 
@@ -19,52 +20,45 @@ class Checkable(BaseModel):
     checked: bool
     error: str | None = Field(default=None)
 
-    @property
-    def id(self) -> str:
-        id = f"{self.name}-{self.value}-{self.token}"
-        return id.replace(".", "-").replace("_", "-")
+    id: str | None = Field(default=None)
+    field_name: str | None = Field(default=None)
 
-    @property
-    def field_name(self) -> str:
-        return f"{self.name}[]"
+    @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
 
 
 class ChecklistWidget(Widget[Sequence[Checkable]]):
     """
     Widget for field of type Set.
-
-    :param name: field 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 removable: display a button to remove the widget for optional fields.
-    :param token: token used to get unique id on the form.
     """
 
-    def __init__(
-        self,
-        name: str,
-        *,
-        title: str | None,
-        hint: str | None = None,
-        aria_label: str | None = None,
-        value: Sequence[Checkable],
-        error: str | None = None,
-        token: str,
-        removable: bool,
-    ) -> None:
-        super().__init__(
-            name,
-            value=value,
-            error=error,
-            token=token,
-            title=title,
-            hint=hint,
-            aria_label=aria_label,
-            removable=removable,
-        )
-
-    def get_template(self) -> str:
-        return "pydantic_form.Checklist.jinja"
+    template = """
+    <pydantic_form.Widget :widget_id="id" :removable="removable">
+      <div class="pt-4">
+        <Details>
+          <Summary :id="id + '-summary'">
+            <H3 :class="H3_SUMMARY_CLASS">{{title}}</H3>
+            <pydantic_form.Error :text="error" />
+          </Summary>
+          <div>
+            {% for value in value %}
+            <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">
+                    {{- value.label -}}
+                </Label>
+                <pydantic_form.Error :text="value.error" />
+            </div>
+            {% endfor %}
+          </div>
+        </Details>
+      </div>
+    </pydantic_form.Widget>
+    """

fastlife/adapters/jinjax/widgets/dropdown.py

@@ -4,53 +4,47 @@ Widget for field of type Enum or Literal.
 
 from collections.abc import Sequence
 
+from pydantic import Field, field_validator
+
 from .base import Widget
 
 
 class DropDownWidget(Widget[str]):
     """
     Widget for field of type Enum or Literal.
+    """
 
-    :param name: field 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 options: List of possible values.
-    :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 class="pt-4">
+        <Label :for="id">{{title}}</Label>
+        <Select :name="name" :id="id">
+          {%- for opt in options -%}
+          <Option :value="opt.value" id={{id + "-" + opt.value.replace(" ", " -")}}
+            :selected="value==opt.value">
+            {{- opt.text -}}
+          </Option>
+          {%- endfor -%}
+        </Select>
+        <pydantic_form.Error :text="error" />
+        <pydantic_form.Hint :text="hint" />
+      </div>
+    </pydantic_form.Widget>
     """
 
-    def __init__(
-        self,
-        name: str,
-        *,
-        title: str | None,
-        hint: str | None = None,
-        aria_label: str | None = None,
-        value: str | None = None,
-        error: str | None = None,
-        options: Sequence[tuple[str, str]] | Sequence[str],
-        removable: bool = False,
-        token: str | None = None,
-    ) -> None:
-        super().__init__(
-            name,
-            value=value,
-            error=error,
-            title=title,
-            token=token,
-            removable=removable,
-            hint=hint,
-            aria_label=aria_label,
-        )
-        self.options: list[dict[str, str]] = []
+    options: list[dict[str | int, str | int]] = Field(default_factory=list)
+
+    @field_validator("options", mode="before")
+    @classmethod
+    def validate_options(
+        cls, options: Sequence[str | int | tuple[str | int, str | int]] | None
+    ) -> Sequence[dict[str | int, str | int]]:
+        if not options:
+            return []
+        ret: list[dict[str | int, str | int]] = []
         for opt in options:
             if isinstance(opt, tuple):
-                self.options.append({"value": opt[0], "text": opt[1]})
+                ret.append({"value": opt[0], "text": opt[1]})
             else:
-                self.options.append({"value": opt, "text": opt})
-
-    def get_template(self) -> str:
-        return "pydantic_form.Dropdown.jinja"
+                ret.append({"value": opt, "text": opt})
+        return ret

fastlife/adapters/jinjax/widgets/hidden.py

@@ -1,33 +1,25 @@
 """Hidden fields"""
 
-from typing import Any
+from fastlife.domain.model.types import Builtins
 
 from .base import Widget
 
 
-class HiddenWidget(Widget[str]):
+class HiddenWidget(Widget[Builtins]):
     '''
     Widget to annotate to display a field as an hidden field.
 
     ::
         from pydantic import BaseModel
+        from fastlife.adapters.jinjax.widgets.base import CustomWidget
         from fastlife.adapters.jinjax.widgets.hidden import HiddenWidget
 
         class MyForm(BaseModel):
-            id: Annotated[str, HiddenWidget] = Field(...)
+            id: Annotated[str, CustomWidget(HiddenWidget)] = Field(...)
             """Identifier in the database."""
 
     '''
 
-    def __init__(
-        self,
-        name: str,
-        *,
-        value: str,
-        token: str,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(name, value=value, token=token)
-
-    def get_template(self) -> str:
-        return "pydantic_form.Hidden.jinja"
+    template = """
+    <Hidden :name="name" :value="value" :id="id" />
+    """

fastlife/adapters/jinjax/widgets/model.py

@@ -1,51 +1,44 @@
 """Pydantic models"""
 
 from collections.abc import Sequence
-from typing import Any
 
 from markupsafe import Markup
-
-from fastlife.services.templates import AbstractTemplateRenderer
-
-from .base import Widget
-
-
-class ModelWidget(Widget[Sequence[Widget[Any]]]):
-    def __init__(
-        self,
-        name: str,
-        *,
-        value: Sequence[Widget[Any]],
-        error: str | None = None,
-        removable: bool,
-        title: str,
-        hint: str | None = None,
-        aria_label: str | None = None,
-        token: str,
-        nested: bool,
-    ):
-        super().__init__(
-            name,
-            title=title,
-            hint=hint,
-            aria_label=aria_label,
-            value=value,
-            error=error,
-            removable=removable,
-            token=token,
-        )
-        self.nested = nested
-
-    def get_template(self) -> str:
-        return "pydantic_form.Model.jinja"
+from pydantic import Field
+
+from fastlife.service.templates import AbstractTemplateRenderer
+
+from .base import TWidget, Widget
+
+
+class ModelWidget(Widget[Sequence[TWidget]]):
+    template = """
+    <pydantic_form.Widget :widget_id="id" :removable="removable">
+    <div id="{{id}}"{% if nested %} class="m-4"{%endif%}>
+        {% if nested %}
+        <Details>
+        <Summary :id="id + '-summary'">
+            <H3 :class="H3_SUMMARY_CLASS">{{title}}</H3>
+            <pydantic_form.Error :text="error" />
+        </Summary>
+        <div>
+            {% for child in children_widgets %}
+            {{ child }}
+            {% endfor %}
+        </div>
+        </Details>
+        {% else %}
+            {% for child in children_widgets %}
+            {{ child }}
+            {% endfor %}
+        {% endif %}
+    </div>
+    </pydantic_form.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."""
-        children_widget = [child.to_html(renderer) for child in self.value or []]
-        kwargs = {
-            "widget": self,
-            "children_widget": children_widget,
-        }
-        return Markup(
-            renderer.render_template(self.get_template(), globals=None, **kwargs)
-        )
+        self.children_widgets = [child.to_html(renderer) for child in self.value or []]
+        return Markup(renderer.render_template(self))