fastlifeweb 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

fastlife/__init__.py

@@ -1,6 +1,7 @@
 from .configurator import Configurator, configure
 from .configurator.registry import Registry
-from .request.form_data import model
+
+# from .request.form_data import model
 from .templating import Template, template
 
 __all__ = [
@@ -11,5 +12,5 @@ __all__ = [
     "Template",
     "Registry",
     # Model
-    "model",
+    # "model",
 ]

fastlife/request/form_data.py

@@ -1,18 +1,14 @@
 from typing import (
     Annotated,
     Any,
-    Callable,
     Mapping,
     MutableMapping,
     MutableSequence,
     Optional,
     Sequence,
-    Type,
-    TypeVar,
 )
 
 from fastapi import Depends, Request
-from pydantic import BaseModel
 
 from fastlife.configurator.registry import Registry
 
@@ -80,7 +76,13 @@ async def unflatten_mapping_form_data(
     form_data = await request.form()
     form_data_decode_list: MutableMapping[str, Any] = {}
     for key, val in form_data.multi_items():
-        if key in form_data_decode_list:
+        if key.endswith("[]"):
+            key = key[:-2]
+            if key not in form_data_decode_list:
+                form_data_decode_list[key] = [val]
+            else:
+                form_data_decode_list[key].append(val)
+        elif key in form_data_decode_list:
             if not isinstance(form_data_decode_list, list):
                 form_data_decode_list[key] = [form_data_decode_list[key]]
             form_data_decode_list[key].append(val)
@@ -105,20 +107,3 @@ async def unflatten_sequence_form_data(
 
 MappingFormData = Annotated[Mapping[str, Any], Depends(unflatten_mapping_form_data)]
 SequenceFormData = Annotated[Sequence[str], Depends(unflatten_sequence_form_data)]
-
-
-T = TypeVar("T", bound=BaseModel)
-"""Template type for form serialized model"""
-
-
-def model(cls: Type[T], name: Optional[str] = None) -> Callable[[Mapping[str, Any]], 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) -> Optional[T]:
-        if data:
-            return cls(**data[name or registry.settings.form_data_model_prefix])
-        return None
-
-    return Depends(to_model)

fastlife/request/model_result.py

@@ -0,0 +1,91 @@
+from typing import Any, Callable, Generic, Mapping, Type, TypeVar, get_origin
+
+from fastapi import Depends
+from pydantic import BaseModel, ValidationError
+
+from fastlife.configurator.registry import Registry
+from fastlife.request.form_data import MappingFormData
+from fastlife.shared_utils.infer import is_union
+
+T = TypeVar("T", bound=BaseModel)
+"""Template type for form serialized model"""
+
+
+class ModelResult(Generic[T]):
+    prefix: str
+    model: T
+    errors: Mapping[str, str]
+    is_valid: bool
+
+    def __init__(
+        self, prefix: str, model: T, errors: Mapping[str, Any], is_valid: bool = False
+    ) -> None:
+        self.prefix = prefix
+        self.model = model
+        self.errors = errors
+        self.is_valid = is_valid
+
+    @classmethod
+    def default(cls, prefix: str, pydantic_type: Type[T]) -> "ModelResult[T]":
+        return cls(prefix, pydantic_type.model_construct(), {})
+
+    @property
+    def form_data(self) -> Mapping[str, Any]:
+        return {self.prefix: self.model.model_dump()}
+
+    @classmethod
+    def from_payload(
+        cls, prefix: str, pydantic_type: Type[T], data: Mapping[str, Any]
+    ) -> "ModelResult[T]":
+        try:
+            return cls(prefix, pydantic_type(**data.get(prefix, {})), {}, True)
+        except ValidationError as exc:
+            errors: dict[str, str] = {}
+            for error in exc.errors():
+                loc = prefix
+                typ: Any = pydantic_type
+                for part in error["loc"]:
+                    if isinstance(part, str):
+                        type_origin = get_origin(typ)
+                        if type_origin:
+                            if is_union(typ):
+                                args = typ.__args__
+                                for arg in args:
+                                    if arg.__name__ == part:
+                                        typ = arg
+                                        continue
+
+                            else:
+                                raise NotImplementedError
+                        elif issubclass(typ, BaseModel):
+                            typ = typ.model_fields[part].annotation
+                            loc = f"{loc}.{part}"
+                        else:
+                            raise NotImplementedError
+
+                    else:
+                        # it is an integer and it part of the list
+                        loc = f"{loc}.{part}"
+
+                if loc in errors:
+                    errors[loc] = f"{errors[loc]}, {error['msg']}"
+                else:
+                    errors[loc] = error["msg"]
+            model = pydantic_type.model_construct(**data.get(prefix, {}))
+            return cls(prefix, model, errors)
+
+
+def model(
+    cls: Type[T], name: str | None = None
+) -> Callable[[Mapping[str, Any]], ModelResult[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) -> ModelResult[T]:
+        prefix = name or registry.settings.form_data_model_prefix
+        if not data:
+            return ModelResult[T].default(prefix, cls)
+        return ModelResult[T].from_payload(prefix, cls, data)
+
+    return Depends(to_model)

fastlife/shared_utils/infer.py

@@ -5,7 +5,7 @@ from pydantic import BaseModel
 
 
 def is_complex_type(typ: Type[Any]) -> bool:
-    return get_origin(typ) or issubclass(typ, BaseModel)
+    return bool(get_origin(typ) or issubclass(typ, BaseModel))
 
 
 def is_union(typ: Type[Any]) -> bool:

fastlife/templates/pydantic_form/Boolean.jinja

@@ -1,7 +1,12 @@
 {# def widget #}
 <pydantic_form.Widget widget={widget} removable={widget.removable}>
   <div class="pt-4">
-    <Label for={widget.id}>{{widget.title}}</Label>
-    <Checkbox name={widget.name} type="checkbox" id={widget.id} checked={widget.value} />
+    <div class="flex items-center">
+      <Checkbox name={widget.name} type="checkbox" id={widget.id} checked={widget.value} value="1" />
+      <Label for={widget.id} class="ms-2 text-base text-neutral-900 dark:text-white">
+        {{widget.title|safe}}
+      </Label>
+    </div>
+    <pydantic_form.Error text={widget.error} />
   </div>
 </pydantic_form.Widget>

fastlife/templates/pydantic_form/Checklist.jinja

@@ -7,12 +7,14 @@ widget,
     <details open>
       <summary class="justify-between items-center font-medium cursor-pointer">
         <H3>{{widget.title}}</H3>
+        <pydantic_form.Error text={widget.error} />
       </summary>
       <div>
         {% for value in widget.value %}
         <div class="flex items-center mb-4">
-          <Checkbox name={widget.name} type="checkbox" id={value.id} value={value.value} checked={value.checked} />
+          <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>

fastlife/templates/pydantic_form/Dropdown.jinja

@@ -10,6 +10,7 @@
       </Option>
       {%- endfor -%}
     </Select>
+    <pydantic_form.Error text={widget.error} />
     <pydantic_form.Hint text={widget.hint} />
   </div>
 </pydantic_form.Widget>

fastlife/templates/pydantic_form/Error.jinja

@@ -0,0 +1,4 @@
+{# def text #}
+{% if text %}
+<span class="mt-2 text-sm text-danger-500 dark:text-danger-400">{{text}}</span>
+{% endif %}

fastlife/templates/pydantic_form/Model.jinja

@@ -5,6 +5,7 @@
     <details open>
       <summary class="justify-between items-center font-medium cursor-pointer">
         <H3>{{widget.title}}</H3>
+        <pydantic_form.Error text={widget.error} />
       </summary>
       <div>
         {% for child in children_widget %}

fastlife/templates/pydantic_form/Sequence.jinja

@@ -4,6 +4,7 @@
   <details id="{{widget.id}}" open>
     <summary class="justify-between items-center font-medium cursor-pointer">
       <H3>{{widget.title}}</H3>
+      <pydantic_form.Error text={widget.error} />
     </summary>
     <div>
       {% set fnGetName = "get" + widget.id.replace("-", "_") %}

fastlife/templates/pydantic_form/Text.jinja

@@ -3,6 +3,7 @@
 <pydantic_form.Widget widget={widget} removable={widget.removable}>
   <div class="pt-4">
     <Label for={widget.id}>{{widget.title}}</Label>
+    <pydantic_form.Error text={widget.error} />
     <Input name={widget.name} value={widget.value} type={widget.input_type} id={widget.id}
       aria-label={widget.aria_label} placeholder={widget.placeholder} />
     <pydantic_form.Hint text={widget.hint} />

fastlife/templates/pydantic_form/Union.jinja

@@ -5,20 +5,20 @@
     <details open>
       <summary class="justify-between items-center font-medium cursor-pointer">
         <H3>{{widget.title}}</H3>
+        <pydantic_form.Error text={widget.error} />
       </summary>
       <div hx-sync="this" id="{{widget.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}
+        <Button type="button" hx-target="closest div" hx-get={typ.url} hx-vals={typ.params|tojson} id={typ.id}
           onclick={"document.getElementById('" + widget.id +"-remove-btn').hidden=false"}>{{typ.title}}</Button>
         {% endfor %}
         {% endif %}
       </div>
-      <Button type="button" id={widget.id + "-remove-btn" } hx-target={"#" + widget.id} hx-vals={parent_type.params|tojson}
-        hx-get={parent_type.url} hidden={not child}>
+      <Button type="button" id={widget.id + "-remove-btn" } hx-target={"#" + widget.id}
+        hx-vals={parent_type.params|tojson} hx-get={parent_type.url} hidden={not child}>
         Remove
       </Button>
     </details>

fastlife/templating/renderer/abstract.py

@@ -5,6 +5,8 @@ from fastapi import Request
 from markupsafe import Markup
 from pydantic.fields import FieldInfo
 
+from fastlife.request.model_result import ModelResult
+
 
 class AbstractTemplateRenderer(abc.ABC):
     route_prefix: str
@@ -30,8 +32,8 @@ class AbstractTemplateRenderer(abc.ABC):
     @abc.abstractmethod
     def pydantic_form(
         self,
-        model: Type[Any],
-        form_data: Mapping[str, Any] | None = None,
+        model: ModelResult[Any],
+        *,
         name: str | None = None,
         token: str | None = None,
         removable: bool = False,
@@ -39,6 +41,18 @@ class AbstractTemplateRenderer(abc.ABC):
     ) -> Markup:
         ...
 
+    @abc.abstractmethod
+    def pydantic_form_field(
+        self,
+        model: Type[Any],
+        *,
+        name: Optional[str] = None,
+        token: Optional[str] = None,
+        removable: bool = False,
+        field: FieldInfo | None = None,
+    ) -> Markup:
+        ...
+
 
 class AbstractTemplateRendererFactory(abc.ABC):
     @abc.abstractmethod

fastlife/templating/renderer/jinjax.py

@@ -5,6 +5,7 @@ from jinjax.catalog import Catalog
 from markupsafe import Markup
 from pydantic.fields import FieldInfo
 
+from fastlife.request.model_result import ModelResult
 from fastlife.templating.renderer.widgets.factory import WidgetFactory
 
 if TYPE_CHECKING:
@@ -69,8 +70,8 @@ class JinjaxRenderer(AbstractTemplateRenderer):
 
     def pydantic_form(
         self,
-        model: Type[Any],
-        form_data: Optional[Mapping[str, Any]] = None,
+        model: ModelResult[Any],
+        *,
         name: Optional[str] = None,
         token: Optional[str] = None,
         removable: bool = False,
@@ -78,12 +79,32 @@ class JinjaxRenderer(AbstractTemplateRenderer):
     ) -> Markup:
         return WidgetFactory(self, token).get_markup(
             model,
-            form_data or {},
-            prefix=(name or self.form_data_model_prefix),
             removable=removable,
             field=field,
         )
 
+    def pydantic_form_field(
+        self,
+        model: Type[Any],
+        *,
+        name: Optional[str] = None,
+        token: Optional[str] = None,
+        removable: bool = False,
+        field: FieldInfo | None = None,
+    ) -> Markup:
+        return (
+            WidgetFactory(self, token)
+            .get_widget(
+                model,
+                form_data={},
+                form_errors={},
+                prefix=(name or self.form_data_model_prefix),
+                removable=removable,
+                field=field,
+            )
+            .to_html(self)
+        )
+
 
 class JinjaxTemplateRenderer(AbstractTemplateRendererFactory):
     route_prefix: str

fastlife/templating/renderer/widgets/base.py

@@ -1,6 +1,6 @@
 import abc
 import secrets
-from typing import Any, Generic, Mapping, Optional, Type, TypeVar
+from typing import Any, Generic, Mapping, Type, TypeVar
 
 from markupsafe import Markup
 
@@ -34,14 +34,16 @@ class Widget(abc.ABC, Generic[T]):
         self,
         name: str,
         *,
-        value: Optional[T] = None,
-        title: Optional[str] = None,
-        token: Optional[str] = None,
-        aria_label: Optional[str] = None,
+        value: T | None = None,
+        error: str | None = None,
+        title: 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.aria_label = aria_label or ""
         self.token = token or secrets.token_urlsafe(4).replace("_", "-")

fastlife/templating/renderer/widgets/boolean.py

@@ -8,11 +8,17 @@ class BooleanWidget(Widget[bool]):
         *,
         title: str | None,
         value: bool = False,
+        error: str | None = None,
         removable: bool = False,
         token: str,
     ) -> None:
         super().__init__(
-            name, title=title, value=value, removable=removable, token=token
+            name,
+            title=title,
+            value=value,
+            error=error,
+            removable=removable,
+            token=token,
         )
 
     def get_template(self) -> str:

fastlife/templating/renderer/widgets/checklist.py

@@ -1,6 +1,6 @@
 from typing import Sequence
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from .base import Widget
 
@@ -11,12 +11,17 @@ class Checkable(BaseModel):
     value: str
     token: str
     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("_", "-")
 
+    @property
+    def field_name(self) -> str:
+        return f"{self.name}[]"
+
 
 class ChecklistWidget(Widget[Sequence[Checkable]]):
     def __init__(
@@ -25,11 +30,17 @@ class ChecklistWidget(Widget[Sequence[Checkable]]):
         *,
         title: str | None,
         value: Sequence[Checkable],
+        error: str | None = None,
         token: str,
         removable: bool,
     ) -> None:
         super().__init__(
-            name, value=value, token=token, title=title, removable=removable
+            name,
+            value=value,
+            error=error,
+            token=token,
+            title=title,
+            removable=removable,
         )
 
     def get_template(self) -> str:

fastlife/templating/renderer/widgets/dropdown.py

@@ -10,13 +10,19 @@ class DropDownWidget(Widget[str]):
         *,
         title: Optional[str],
         value: Optional[str] = None,
+        error: str | None = None,
         options: Sequence[Tuple[str, str]] | Sequence[str],
         removable: bool = False,
         token: Optional[str] = None,
         hint: Optional[str] = None,
     ) -> None:
         super().__init__(
-            name, value=value, title=title, token=token, removable=removable
+            name,
+            value=value,
+            error=error,
+            title=title,
+            token=token,
+            removable=removable,
         )
         self.options: list[dict[str, str]] = []
         for opt in options: