fastlifeweb 0.5.1__tar.gz → 0.6.0__tar.gz

{fastlifeweb-0.5.1 → fastlifeweb-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastlifeweb
-Version: 0.5.1
+Version: 0.6.0
 Summary: High-level web framework
 Home-page: https://github.com/mardiros/fastlife
 License: BSD-derived
@@ -24,7 +24,7 @@ Requires-Dist: itsdangerous (>=2.1.2,<3.0.0)
 Requires-Dist: jinjax (>=0.34,<0.35)
 Requires-Dist: markupsafe (>=2.1.3,<3.0.0)
 Requires-Dist: multidict (>=6.0.5,<7.0.0)
-Requires-Dist: pydantic (>=2.3.0,<3.0.0)
+Requires-Dist: pydantic (==2.5.1)
 Requires-Dist: pydantic-settings (>=2.0.3,<3.0.0)
 Requires-Dist: python-multipart (>=0.0.6,<0.0.7)
 Requires-Dist: venusian (>=3.0.0,<4.0.0)

{fastlifeweb-0.5.1 → fastlifeweb-0.6.0}/pyproject.toml

@@ -15,21 +15,21 @@ classifiers = [
   "Topic :: Software Development :: Libraries :: Python Modules",
   "Topic :: Internet :: WWW/HTTP",
 ]
-version = "0.5.1"
+version = "0.6.0"
 
 [tool.poetry.dependencies]
 python = "^3.11"
 beautifulsoup4 = {version = "^4.12.2", extras = ["testing"]}
+behave = "^1.2.6"
 fastapi = "^0.110.0"
+itsdangerous = "^2.1.2"
 jinjax = "^0.34"
-pydantic = "^2.3.0"
+markupsafe = "^2.1.3"
+multidict = "^6.0.5"
+pydantic = "2.5.1"
 pydantic-settings = "^2.0.3"
 python-multipart = "^0.0.6"
 venusian = "^3.0.0"
-markupsafe = "^2.1.3"
-behave = "^1.2.6"
-itsdangerous = "^2.1.2"
-multidict = "^6.0.5"
 
 [tool.poetry.group.dev.dependencies]
 beautifulsoup4 = "^4.12.2"
@@ -67,6 +67,7 @@ filterwarnings = [
   'ignore:.*Deprecated call to `pkg_resources.declare_namespace:DeprecationWarning', # venusian
   'ignore:.*find_module\(\) is deprecated.*:DeprecationWarning',
   'ignore:.*FileFinder.find_loader\(\) is deprecated.*:DeprecationWarning',
+  'ignore:.*Pydantic serializer warnings.*:UserWarning',
 ]
 testpaths = ["tests"]
 

{fastlifeweb-0.5.1 → fastlifeweb-0.6.0}/src/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",
 ]

{fastlifeweb-0.5.1 → fastlifeweb-0.6.0}/src/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)

fastlifeweb-0.6.0/src/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)

{fastlifeweb-0.5.1 → fastlifeweb-0.6.0}/src/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:

{fastlifeweb-0.5.1 → fastlifeweb-0.6.0}/src/fastlife/templates/pydantic_form/Checklist.jinja

@@ -11,7 +11,7 @@ widget,
       <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>
         </div>
         {% endfor %}

fastlifeweb-0.6.0/src/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 %}

{fastlifeweb-0.5.1 → fastlifeweb-0.6.0}/src/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} />

{fastlifeweb-0.5.1 → fastlifeweb-0.6.0}/src/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

{fastlifeweb-0.5.1 → fastlifeweb-0.6.0}/src/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

{fastlifeweb-0.5.1 → fastlifeweb-0.6.0}/src/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("_", "-")

{fastlifeweb-0.5.1 → fastlifeweb-0.6.0}/src/fastlife/templating/renderer/widgets/checklist.py

@@ -17,6 +17,10 @@ class Checkable(BaseModel):
         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__(

{fastlifeweb-0.5.1 → fastlifeweb-0.6.0}/src/fastlife/templating/renderer/widgets/factory.py

@@ -2,6 +2,7 @@ import secrets
 from collections.abc import MutableSequence, Sequence
 from decimal import Decimal
 from enum import Enum
+from inspect import isclass
 from types import NoneType
 from typing import Any, Literal, Mapping, Optional, Type, cast, get_origin
 from uuid import UUID
@@ -10,6 +11,7 @@ from markupsafe import Markup
 from pydantic import BaseModel, EmailStr, SecretStr, ValidationError
 from pydantic.fields import FieldInfo
 
+from fastlife.request.model_result import ModelResult
 from fastlife.shared_utils.infer import is_complex_type, is_union
 from fastlife.templating.renderer.abstract import AbstractTemplateRenderer
 from fastlife.templating.renderer.widgets.boolean import BooleanWidget
@@ -31,21 +33,25 @@ class WidgetFactory:
 
     def get_markup(
         self,
-        base: Type[Any],
-        form_data: Mapping[str, Any],
+        model: ModelResult[Any],
         *,
-        prefix: str,
         removable: bool,
         field: FieldInfo | None = None,
     ) -> Markup:
         return self.get_widget(
-            base, form_data, prefix=prefix, removable=removable, field=field
+            model.model.__class__,
+            model.form_data,
+            model.errors,
+            prefix=model.prefix,
+            removable=removable,
+            field=field,
         ).to_html(self.renderer)
 
     def get_widget(
         self,
         base: Type[Any],
         form_data: Mapping[str, Any],
+        form_errors: Mapping[str, Any],
         *,
         prefix: str,
         removable: bool,
@@ -54,6 +60,7 @@ class WidgetFactory:
         return self.build(
             base,
             value=form_data.get(prefix, {}),
+            form_errors=form_errors,
             name=prefix,
             removable=removable,
             field=field,
@@ -66,11 +73,12 @@ class WidgetFactory:
         name: str = "",
         value: Any,
         removable: bool,
+        form_errors: Mapping[str, Any],
         field: FieldInfo | None = None,
     ) -> Widget[Any]:
         if field and field.metadata:
             for widget in field.metadata:
-                if issubclass(widget, Widget):
+                if isclass(widget) and issubclass(widget, Widget):
                     return cast(
                         Widget[Any],
                         widget(
@@ -86,38 +94,52 @@ class WidgetFactory:
         type_origin = get_origin(typ)
         if type_origin:
             if is_union(typ):
-                return self.build_union(name, typ, field, value, removable)
+                return self.build_union(name, typ, field, value, form_errors, removable)
 
             if (
                 type_origin is Sequence
                 or type_origin is MutableSequence
                 or type_origin is list
             ):
-                return self.build_sequence(name, typ, field, value, removable)
+                return self.build_sequence(
+                    name, typ, field, value, form_errors, removable
+                )
 
             if type_origin is Literal:
-                return self.build_literal(name, typ, field, value, removable)
+                return self.build_literal(
+                    name, typ, field, value, form_errors, removable
+                )
 
             if type_origin is set:
-                return self.build_set(name, typ, field, value, removable)
+                return self.build_set(name, typ, field, value, form_errors, removable)
 
         if issubclass(typ, Enum):  # if it raises here, the type_origin is unknown
-            return self.build_enum(name, typ, field, value, removable)
+            return self.build_enum(name, typ, field, value, form_errors, removable)
 
         if issubclass(typ, BaseModel):  # if it raises here, the type_origin is unknown
-            return self.build_model(name, typ, field, value or {}, removable)
+            return self.build_model(
+                name, typ, field, value or {}, form_errors, removable
+            )
 
         if issubclass(typ, bool):
-            return self.build_boolean(name, typ, field, value or False, removable)
+            return self.build_boolean(
+                name, typ, field, value or False, form_errors, removable
+            )
 
         if issubclass(typ, EmailStr):  # type: ignore
-            return self.build_emailtype(name, typ, field, value or "", removable)
+            return self.build_emailtype(
+                name, typ, field, value or "", form_errors, removable
+            )
 
         if issubclass(typ, SecretStr):
-            return self.build_secretstr(name, typ, field, value or "", removable)
+            return self.build_secretstr(
+                name, typ, field, value or "", form_errors, removable
+            )
 
         if issubclass(typ, (int, str, float, Decimal, UUID)):
-            return self.build_simpletype(name, typ, field, value or "", removable)
+            return self.build_simpletype(
+                name, typ, field, value or "", form_errors, removable
+            )
 
         raise NotImplementedError(f"{typ} not implemented")  # coverage: ignore
 
@@ -127,6 +149,7 @@ class WidgetFactory:
         typ: Type[BaseModel],
         field: Optional[FieldInfo],
         value: Mapping[str, Any],
+        form_errors: Mapping[str, Any],
         removable: bool,
     ) -> Widget[Any]:
         ret: dict[str, Any] = {}
@@ -143,6 +166,7 @@ class WidgetFactory:
                 name=child_key,
                 field=field,
                 value=value.get(key),
+                form_errors=form_errors,
                 removable=False,
             )
         return ModelWidget(
@@ -159,6 +183,7 @@ class WidgetFactory:
         field_type: Type[Any],
         field: Optional[FieldInfo],
         value: Any,
+        form_errors: Mapping[str, Any],
         removable: bool,
     ) -> Widget[Any]:
         types: list[Type[Any]] = []
@@ -176,7 +201,12 @@ class WidgetFactory:
             and not is_complex_type(types[0])
         ):
             return self.build(
-                types[0], name=field_name, field=field, value=value, removable=False
+                types[0],
+                name=field_name,
+                field=field,
+                value=value,
+                form_errors=form_errors,
+                removable=False,
             )
         child = None
         if value:
@@ -191,6 +221,7 @@ class WidgetFactory:
                         name=field_name,
                         field=field,
                         value=value,
+                        form_errors=form_errors,
                         removable=False,
                     )
 
@@ -212,6 +243,7 @@ class WidgetFactory:
         field_type: Type[Any],
         field: Optional[FieldInfo],
         value: Optional[Sequence[Any]],
+        form_errors: Mapping[str, Any],
         removable: bool,
     ) -> Widget[Any]:
         typ = field_type.__args__[0]  # type: ignore
@@ -222,6 +254,7 @@ class WidgetFactory:
                 name=f"{field_name}.{idx}",
                 value=v,
                 field=field,
+                form_errors=form_errors,
                 removable=True,
             )
             for idx, v in enumerate(value)
@@ -242,6 +275,7 @@ class WidgetFactory:
         field_type: Type[Any],
         field: Optional[FieldInfo],
         value: Optional[Sequence[Any]],
+        form_errors: Mapping[str, Any],
         removable: bool,
     ) -> Widget[Any]:
         choice_wrapper = field_type.__args__[0]
@@ -291,6 +325,7 @@ class WidgetFactory:
         field_type: Type[Any],
         field: FieldInfo | None,
         value: bool,
+        form_errors: Mapping[str, Any],
         removable: bool,
     ) -> Widget[Any]:
         return BooleanWidget(
@@ -307,6 +342,7 @@ class WidgetFactory:
         field_type: Type[Any],
         field: FieldInfo | None,
         value: str | int | float,
+        form_errors: Mapping[str, Any],
         removable: bool,
     ) -> Widget[Any]:
         return TextWidget(
@@ -326,6 +362,7 @@ class WidgetFactory:
         field_type: Type[Any],
         field: FieldInfo | None,
         value: SecretStr | str,
+        form_errors: Mapping[str, Any],
         removable: bool,
     ) -> Widget[Any]:
         return TextWidget(
@@ -345,6 +382,7 @@ class WidgetFactory:
         field_type: Type[Any],  # a literal actually
         field: FieldInfo | None,
         value: str | int | float,
+        form_errors: Mapping[str, Any],
         removable: bool,
     ) -> Widget[Any]:
         choices: list[str] = field_type.__args__  # type: ignore
@@ -369,6 +407,7 @@ class WidgetFactory:
         field_type: Type[Any],  # an enum subclass
         field: FieldInfo | None,
         value: str | int | float,
+        form_errors: Mapping[str, Any],
         removable: bool,
     ) -> Widget[Any]:
         options = [(item.name, item.value) for item in field_type]  # type: ignore
@@ -387,6 +426,7 @@ class WidgetFactory:
         field_type: Type[Any],
         field: FieldInfo | None,
         value: str | int | float,
+        form_errors: Mapping[str, Any],
         removable: bool,
     ) -> Widget[Any]:
         return TextWidget(
@@ -398,4 +438,5 @@ class WidgetFactory:
             title=field.title if field else "",
             token=self.token,
             value=str(value),
+            error=form_errors.get(field_name),
         )

{fastlifeweb-0.5.1 → fastlifeweb-0.6.0}/src/fastlife/templating/renderer/widgets/text.py

@@ -11,11 +11,12 @@ class TextWidget(Widget[str]):
         title: Optional[str],
         aria_label: Optional[str] = None,
         placeholder: Optional[str] = None,
+        error: str | None = None,
         removable: bool = False,
         value: str = "",
         token: Optional[str] = None,
         hint: Optional[str] = None,
-        input_type: str = "text"
+        input_type: str = "text",
     ) -> None:
         super().__init__(
             name,
@@ -23,6 +24,7 @@ class TextWidget(Widget[str]):
             title=title,
             aria_label=aria_label,
             token=token,
+            error=error,
             removable=removable,
         )
         self.placeholder = placeholder or ""

{fastlifeweb-0.5.1 → fastlifeweb-0.6.0}/src/fastlife/testing/testclient.py

@@ -1,3 +1,5 @@
+"""Testing your application."""
+
 import re
 import time
 from collections.abc import MutableMapping
@@ -20,41 +22,67 @@ Cookies = httpx._models.Cookies  # type: ignore
 
 
 class Element:
+    """Access to a dom element."""
+
     def __init__(self, client: "WebTestClient", tag: bs4.Tag):
         self._client = client
         self._tag = tag
 
     def click(self) -> "WebResponse":
+        """Simulate a client to a a link. No javascript exectuted here."""
         return self._client.get(self._tag.attrs["href"])
 
     @property
     def node_name(self) -> str:
+        """Get the node name of the dom element."""
         return self._tag.name
 
     @property
     def attrs(self) -> dict[str, str]:
+        """Attributes of the element."""
         return self._tag.attrs
 
     @property
     def text(self) -> str:
+        """
+        Return the text of the element, with text of childs element.
+
+        Note that the text is stripped for convenience but inner text may contains
+        many spaces not manipulated here.
+        """
         return self._tag.text.strip()
 
     @property
     def h1(self) -> "Element":
+        """
+        Return the h1 child element.
+
+        Should be used on the html body element directly.
+        """
         nodes = self.by_node_name("h1")
         assert len(nodes) == 1, f"Should have 1 <h1>, got {len(nodes)} in {self}"
         return nodes[0]
 
     @property
     def h2(self) -> Sequence["Element"]:
+        """
+        Return the h2 elements.
+        """
         return self.by_node_name("h2")
 
     @property
     def form(self) -> "Element | None":
+        """Get the form element of the web page."""
         return Element(self._client, self._tag.form) if self._tag.form else None
 
     @property
     def hx_target(self) -> Optional[str]:
+        """
+        Return the hx-target of the element.
+
+        It may be set on a parent. It also resolve special case "this" and return the id
+        of the element.
+        """
         el: bs4.Tag | None = self._tag
         while el:
             if "hx-target" in el.attrs:
@@ -66,12 +94,14 @@ class Element:
         return None
 
     def by_text(self, text: str, *, node_name: str | None = None) -> "Element | None":
+        """Find the first element that match the text."""
         nodes = self.iter_all_by_text(text, node_name=node_name)
         return next(nodes, None)
 
     def iter_all_by_text(
         self, text: str, *, node_name: str | None = None
     ) -> "Iterator[Element]":
+        """Return an iterator of all elements that match the text."""
         nodes = self._tag.find_all(string=re.compile(rf"\s*{text}\s*"))
         for node in nodes:
             if isinstance(node, bs4.NavigableString):
@@ -89,10 +119,12 @@ class Element:
     def get_all_by_text(
         self, text: str, *, node_name: str | None = None
     ) -> "Sequence[Element]":
+        """Return the list of all elements that match the text."""
         nodes = self.iter_all_by_text(text, node_name=node_name)
         return list(nodes)
 
     def by_label_text(self, text: str) -> "Element | None":
+        """Return the element which is the target of the label having the given text."""
         label = self.by_text(text, node_name="label")
         assert label is not None
         assert label.attrs.get("for") is not None
@@ -103,6 +135,11 @@ class Element:
     def by_node_name(
         self, node_name: str, *, attrs: dict[str, str] | None = None
     ) -> list["Element"]:
+        """
+        Return the list of elements with the given node_name.
+
+        An optional set of attributes may given and must match if passed.
+        """
         return [
             Element(self._client, e) for e in self._tag.find_all(node_name, attrs or {})
         ]
@@ -115,6 +152,15 @@ class Element:
 
 
 class WebForm:
+    """
+    Handle form.
+
+    Form are filled out and submit with methods and try to avoid invalid
+    usage, such as selecting an option that don't exists is not possible here.
+    Again, no javascript is executed here, but htmx attribute `hx-post` and `hx-target`
+    are read while submiting to simulate it.
+    """
+
     def __init__(self, client: "WebTestClient", origin: str, form: Element):
         self._client = client
         self._form = form
@@ -154,6 +200,14 @@ class WebForm:
         # field textearea...
 
     def set(self, fieldname: str, value: str) -> Any:
+        """
+        Set a value to an input field.
+
+        It works for checkbox and radio as well.
+        Checkbox may contains many values.
+        Options of select can't be set with this method, the select method must
+        be used instead.
+        """
         if fieldname not in self._formfields:
             raise ValueError(f'"{fieldname}" does not exists')
         if self._formfields[fieldname].node_name == "select":
@@ -175,6 +229,7 @@ class WebForm:
         self._formdata[fieldname] = value
 
     def unset(self, fieldname: str, value: str) -> Any:
+        """Unset an element. Only works with checkbox."""
         if fieldname not in self._formfields:
             raise ValueError(f'"{fieldname}" does not exists')
         if self._formfields[fieldname].node_name != "input":
@@ -189,6 +244,9 @@ class WebForm:
                 self._formdata[fieldname] = val
 
     def select(self, fieldname: str, value: str) -> Any:
+        """
+        Select an option, if multiple, value is added, otherwise, value is replaced.
+        """
         if fieldname not in self._formfields:
             raise ValueError(f'"{fieldname}" does not exists')
         field = self._formfields[fieldname]
@@ -206,6 +264,9 @@ class WebForm:
             raise ValueError(f'No option {value} in <select name="{fieldname}">')
 
     def unselect(self, fieldname: str, value: str) -> Any:
+        """
+        Unselect an option if multiple, otherwise an exception is raised.
+        """
         if fieldname not in self._formfields:
             raise ValueError(f'"{fieldname}" does not exists')
         field = self._formfields[fieldname]
@@ -231,6 +292,20 @@ class WebForm:
             raise ValueError(f'No option {value} in <select name="{fieldname}">')
 
     def button(self, text: str, position: int = 0) -> "WebForm":
+        """
+        Simmulate a click on a button using the text of the button,
+
+        and eventually a position. The button return the form and the submit()
+        should be called directly.
+
+        This is used in order to inject the value of the button in the form, usually
+        done while many actions are available on a form.
+
+        ::
+
+            form.button("Go").submit()
+
+        """
         buttons = self._form.get_all_by_text(text, node_name="button")
         if position >= len(buttons):
             pos = ""
@@ -243,6 +318,9 @@ class WebForm:
         return self
 
     def submit(self, follow_redirects: bool = True) -> "WebResponse":
+        """
+        Submit the form as it has been previously filled out.
+        """
         headers: dict[str, str] = {}
         target = (
             self._form.attrs.get("hx-post")
@@ -261,10 +339,13 @@ class WebForm:
         )
 
     def __contains__(self, key: str) -> bool:
+        """Test if a field exists in the form."""
         return key in self._formdata
 
 
 class WebResponse:
+    """Represent an http response made by the WebTestClient browser."""
+
     def __init__(self, client: "WebTestClient", origin: str, response: httpx.Response):
         self._client = client
         self._response = response
@@ -274,38 +355,46 @@ class WebResponse:
 
     @property
     def status_code(self) -> int:
+        """Http status code."""
         return self._response.status_code
 
     @property
     def is_redirect(self) -> bool:
+        """True for any kind of http redirect status."""
         return 300 <= self._response.status_code < 400
 
     @property
     def content_type(self) -> str:
+        """Get the content type of the response, from the header."""
         return self._response.headers.get("content-type", "").split(";").pop(0)
 
     @property
     def headers(self) -> httpx.Headers:
+        """All http headers of the response."""
         return self._response.headers
 
     @property
     def text(self) -> str:
+        """Http response body."""
         return self._response.text
 
     @property
     def html(self) -> Element:
+        """Http response body as an Element."""
         if self._html is None:
             self._html = bs4.BeautifulSoup(self._response.text, "html.parser")
         return Element(self._client, self._html)
 
     @property
     def html_body(self) -> Element:
+        """The body element of the html response."""
         body = self.html.by_node_name("body")
         assert len(body) == 1
         return body[0]
 
     @property
     def form(self) -> WebForm:
+        """The form element of the html response."""
         if self._form is None:
             form = self.html.form
             assert form is not None
@@ -313,18 +402,23 @@ class WebResponse:
         return self._form
 
     def by_text(self, text: str, *, node_name: str | None = None) -> Element | None:
+        """Search a dom element by its text."""
         return self.html.by_text(text, node_name=node_name)
 
     def by_label_text(self, text: str) -> Element | None:
+        """Search a dom element by its associated label text."""
         return self.html.by_label_text(text)
 
     def by_node_name(
         self, node_name: str, *, attrs: dict[str, str] | None = None
     ) -> list[Element]:
+        """List dom element having the given node name, and eventually attributes."""
         return self.html.by_node_name(node_name, attrs=attrs)
 
 
 class Session(dict[str, Any]):
+    """Manipulate the session of the WebTestClient browser."""
+
     def __init__(self, client: "WebTestClient"):
         self.client = client
         self.srlz = client.session_serializer
@@ -343,6 +437,7 @@ class Session(dict[str, Any]):
         super().__init__(data)
 
     def __setitem__(self, __key: Any, __value: Any) -> None:
+        """Initialize a value in the session of the client in order to test."""
         super().__setitem__(__key, __value)
         settings = self.settings
         data = self.serialize()
@@ -380,6 +475,8 @@ class Session(dict[str, Any]):
 
 
 class WebTestClient:
+    """The fake browser used for testing purpose."""
+
     def __init__(
         self,
         app: ASGIApp,
@@ -404,10 +501,12 @@ class WebTestClient:
 
     @property
     def cookies(self) -> Cookies:
+        """HTTP Cookies"""
         return self.testclient.cookies
 
     @property
     def session(self) -> MutableMapping[str, Any]:
+        """Session shared between the server and the client."""
         return Session(self)
 
     def request(
@@ -419,6 +518,7 @@ class WebTestClient:
         headers: Mapping[str, str] | None = None,
         max_redirects: int = 0,
     ) -> WebResponse:
+        """Perform http requests."""
         rawresp = self.testclient.request(
             method=method,
             url=url,
@@ -455,6 +555,7 @@ class WebTestClient:
         return resp
 
     def get(self, url: str, follow_redirects: bool = True) -> WebResponse:
+        """Perform http GET request."""
         return self.request(
             "GET",
             url,
@@ -469,6 +570,7 @@ class WebTestClient:
         headers: Mapping[str, Any] | None = None,
         follow_redirects: bool = True,
     ) -> WebResponse:
+        """Perform http POST request in "application/x-www-form-urlencoded" format."""
         if headers is None:
             headers = {}
         return self.request(

{fastlifeweb-0.5.1 → fastlifeweb-0.6.0}/src/fastlife/views/pydantic_form.py

@@ -21,8 +21,12 @@ async def show_widget(
     field = None
     if title:
         field = FieldInfo(title=title)
-    data = reg.renderer(request).pydantic_form(
-        model_cls, None, name, token, removable, field
+    data = reg.renderer(request).pydantic_form_field(
+        model=model_cls,
+        name=name,
+        token=token,
+        removable=removable,
+        field=field,
     )
     return Response(data, headers={"Content-Type": "text/html"})