fastlifeweb 0.16.4__py3-none-any.whl → 0.17.0__py3-none-any.whl

fastlife/adapters/jinjax/widget_factory/set_builder.py

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

fastlife/adapters/jinjax/widget_factory/simpletype_builder.py

@@ -0,0 +1,47 @@
+"""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
+
+
+class SimpleTypeBuilder(BaseWidgetBuilder[str | int | str | float | Decimal | UUID]):
+    """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)
+
+    def build(
+        self,
+        *,
+        field_name: str,
+        field_type: type[Any],
+        field: FieldInfo | None,
+        value: int | str | float | Decimal | UUID | None,
+        form_errors: Mapping[str, Any],
+        removable: bool,
+    ) -> Widget[int | str | float | Decimal | UUID]:
+        """Build the widget."""
+        return TextWidget(
+            field_name,
+            placeholder=str(field.examples[0]) if field and field.examples else None,
+            title=field.title if field else "",
+            hint=field.description if field else None,
+            aria_label=(
+                field.json_schema_extra.get("aria_label")  # type:ignore
+                if field and field.json_schema_extra
+                else None
+            ),
+            removable=removable,
+            token=self.factory.token,
+            value=str(value) if value else "",
+            error=form_errors.get(field_name),
+        )

fastlife/adapters/jinjax/widget_factory/union_builder.py

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

fastlife/adapters/jinjax/widgets/hidden.py

@@ -1,3 +1,5 @@
+"""Hidden fields"""
+
 from typing import Any
 
 from .base import Widget

fastlife/adapters/jinjax/widgets/model.py

@@ -1,3 +1,5 @@
+"""Pydantic models"""
+
 from collections.abc import Sequence
 from typing import Any
 

fastlife/components/Form.jinja

@@ -22,6 +22,15 @@
   ] = None,
   method: Annotated[Literal["get", "post"] | None, "Http method used"] = None,
   action: Annotated[str | None, "url where the form will be submitted"] = None,
+  hx_target: Annotated[
+    str | None,
+    "target the element for swapping than the one issuing the AJAX request."
+  ] = None,
+  hx_select: Annotated[str | None, "select the content swapped from response of the AJAX request."] = None,
+  hx_swap: Annotated[
+    str | None,
+    "specify how the response will be swapped in relative to the target of an AJAX request."
+  ] = None,
   hx_post: Annotated[
     str | Literal[True] | None,
     "url where the form will be submitted using htmx. if ``True``, the current url is used."\
@@ -40,6 +49,9 @@
       {%- if hx_post is not none %}
         hx-post="{% if hx_post is not true %}{{hx_post}}{% endif %}"
       {%- endif %}
+      {%- if hx_select %} hx-select="{{ hx_select }}" {%- endif %}
+      {%- if hx_swap %} hx-swap="{{ hx_swap }}" {%- endif %}
+      {%- if hx_target %} hx-target="{{ hx_target }}" {%- endif %}
     {%- endif %}
     {%- if action is not none %} action="{{action}}" {%- endif %}
     {%- if method %} method="{{method}}" {%- endif -%}

fastlife/config/configurator.py

@@ -11,15 +11,13 @@ The configurator is designed to handle the setup during the configuration
 phase.
 """
 
-import importlib
-import inspect
 import logging
 from collections import defaultdict
 from collections.abc import Callable, Mapping, Sequence
 from enum import Enum
 from pathlib import Path
 from types import ModuleType
-from typing import TYPE_CHECKING, Annotated, Any, Generic, Self
+from typing import TYPE_CHECKING, Annotated, Any, Generic, Self, TypeVar
 
 import venusian
 from fastapi import Depends, FastAPI, Response
@@ -30,12 +28,12 @@ from fastapi.types import IncEx
 
 from fastlife.config.openapiextra import OpenApiTag
 from fastlife.middlewares.base import AbstractMiddleware
-from fastlife.request.request import Request
+from fastlife.request.request import GenericRequest, Request
 from fastlife.routing.route import Route
 from fastlife.routing.router import Router
 from fastlife.security.csrf import check_csrf
 from fastlife.services.policy import check_permission
-from fastlife.shared_utils.resolver import resolve
+from fastlife.shared_utils.resolver import resolve, resolve_maybe_relative
 
 from .registry import DefaultRegistry, TRegistry
 from .settings import Settings
@@ -238,12 +236,11 @@ class GenericConfigurator(Generic[TRegistry]):
         :param ignore: ignore submodules
         """
         if isinstance(module, str):
-            package = None
-            if module.startswith("."):
-                caller_module = inspect.getmodule(inspect.stack()[1][0])
-                package = caller_module.__name__ if caller_module else "__main__"
+            try:
+                module = resolve_maybe_relative(module, stack_depth=2)
+            except ModuleNotFoundError as exc:
+                raise ConfigurationError(f"Can't resolve {module}") from exc
 
-            module = importlib.import_module(module, package)
         old, self._route_prefix = self._route_prefix, route_prefix
         try:
             self.scanner.scan(  # type: ignore
@@ -301,7 +298,7 @@ class GenericConfigurator(Generic[TRegistry]):
         self.api_redoc_url = redoc_url
         return self
 
-    def add_open_tag(self, tag: OpenApiTag) -> Self:
+    def add_openapi_tag(self, tag: OpenApiTag) -> Self:
         """Register a tag description in the documentation."""
         if tag.name in self.tags:
             raise ConfigurationError(f"Tag {tag.name} can't be registered twice.")
@@ -538,8 +535,8 @@ class GenericConfigurator(Generic[TRegistry]):
             # class is wrong.
             # Until we store a security policy per rooter, we rebuild an
             # incomplete request here.
-            request = Request(self.registry, request)
-            resp = handler(request, exc)
+            req = GenericRequest[DefaultRegistry](self.registry, request)
+            resp = handler(req, exc)
             if isinstance(resp, Response):
                 return resp
 
@@ -551,7 +548,7 @@ class GenericConfigurator(Generic[TRegistry]):
                     "did not return a Response"
                 )
 
-            return request.registry.get_renderer(template)(request).render(
+            return req.registry.get_renderer(template)(req).render(
                 template,
                 params=resp,
                 status_code=status_code,
@@ -593,8 +590,11 @@ class Configurator(GenericConfigurator[DefaultRegistry]):
     """
 
 
+TConfigurator = TypeVar("TConfigurator", bound=GenericConfigurator[Any])
+
+
 def configure(
-    wrapped: Callable[[Configurator], None],
+    wrapped: Callable[[TConfigurator], None],
 ) -> Callable[[Any], None]:
     """
     Decorator used to attach route in a submodule while using the configurator.include.

fastlife/config/exceptions.py

@@ -1,3 +1,5 @@
+"""Customize error pages."""
+
 from collections.abc import Callable
 from typing import Any
 

fastlife/config/resources.py

@@ -55,7 +55,7 @@ def resource(
 
     Note that there is no abstract class that declare this method, this is done by
     introspection while returning the configuration method
-    {meth}`fastlife.config.configurator.Configurator.include`
+    {meth}`fastlife.config.configurator.GenericConfigurator.include`
     """
     tag = name
 
@@ -68,7 +68,7 @@ def resource(
 
             config: Configurator = getattr(scanner, VENUSIAN_CATEGORY)
             if description:
-                config.add_open_tag(
+                config.add_openapi_tag(
                     OpenApiTag(
                         name=tag, description=description, externalDocs=external_docs
                     )

fastlife/config/settings.py

@@ -74,6 +74,8 @@ class Settings(BaseSettings):
     )
     """
     Set global constants accessible in every templates.
+    Defaults to `fastlife.templates.constants:Constants`
+    See {class}`fastlife.templates.constants.Constants`
     """
 
     session_secret_key: str = Field(default="")

fastlife/middlewares/reverse_proxy/x_forwarded.py

@@ -9,20 +9,19 @@ log = logging.getLogger(__name__)
 
 
 def get_header(headers: Sequence[tuple[bytes, bytes]], key: bytes) -> str | None:
-    for hdr in headers:
-        if hdr[0].lower() == key:
-            return hdr[1].decode("latin1")
+    for hkey, val in headers:
+        if hkey.lower() == key:
+            return val.decode("latin1")
     return None
 
 
 def get_header_int(headers: Sequence[tuple[bytes, bytes]], key: bytes) -> int | None:
-    for hdr in headers:
-        if hdr[0].lower() == key:
-            ret = hdr[1].decode("latin1")
+    for hkey, val in headers:
+        if hkey.lower() == key:
             try:
-                return int(ret)
+                return int(val.decode("latin1"))
             except ValueError:
-                pass
+                break
     return None
 
 

fastlife/services/policy.py

@@ -13,7 +13,7 @@ def check_permission(permission_name: str) -> CheckPermissionHook:
 
     Adding a permission on the route requires that a security policy has been
     added using the method
-    {meth}`fastlife.config.configurator.Configurator.set_security_policy`
+    {meth}`fastlife.config.configurator.GenericConfigurator.set_security_policy`
 
     :param permission_name: a permission name set in a view to check access.
     :return: a function that raise http exceptions or any configured exception here.

fastlife/services/translations.py

@@ -13,15 +13,21 @@ locale_name = str
 
 
 def find_mo_files(root_path: str) -> Iterator[tuple[str, str, pathlib.Path]]:
+    """
+    Find .mo files in a locales directory.
+
+    :param root_path: locales directory.
+    :return: a tupple containing locale_name, domain, file.
+    """
     root = pathlib.Path(root_path)
 
-    # Walk through the directory structure and match the pattern
     for locale_dir in root.iterdir():
-        if locale_dir.is_dir():  # Ensure it's a directory (locale)
-            lc_messages_dir = locale_dir / "LC_MESSAGES"
-            if lc_messages_dir.exists() and lc_messages_dir.is_dir():
-                for mo_file in lc_messages_dir.glob("*.mo"):  # Find .mo files
-                    yield locale_dir.name, mo_file.name[:-3], mo_file
+        lc_messages_dir = locale_dir / "LC_MESSAGES"
+        if not (locale_dir.is_dir() and lc_messages_dir.is_dir()):
+            continue
+
+        for mo_file in lc_messages_dir.glob("*.mo"):
+            yield locale_dir.name, mo_file.stem, mo_file
 
 
 class Localizer:

fastlife/shared_utils/resolver.py

@@ -1,8 +1,9 @@
 """Resolution of python objects for dependency injection and more."""
 
 import importlib.util
+import inspect
 from pathlib import Path
-from types import UnionType
+from types import ModuleType, UnionType
 from typing import Any, Union
 
 
@@ -51,3 +52,59 @@ def resolve_path(value: str) -> str:
     package_path = spec.origin
     full_path = Path(package_path).parent / resource_name
     return str(full_path)
+
+
+def resolve_package(mod: ModuleType) -> ModuleType:
+    """
+    Return the
+    [regular package](https://docs.python.org/3/glossary.html#term-regular-package)
+    of a module or itself if it is the ini file of a package.
+
+    """
+
+    # Compiled package has no __file__ attribute, ModuleType declare it as NoneType
+    if not hasattr(mod, "__file__") or mod.__file__ is None:
+        return mod
+
+    module_path = Path(mod.__file__)
+    if module_path.name == "__init__.py":
+        return mod
+
+    parent_module_name = mod.__name__.rsplit(".", 1)[0]
+    parent_module = importlib.import_module(parent_module_name)
+    return parent_module
+
+
+def _strip_left_dots(s: str) -> tuple[str, int]:
+    stripped_string = s.lstrip(".")
+    num_stripped_dots = len(s) - len(stripped_string)
+    return stripped_string, num_stripped_dots - 1
+
+
+def _get_parent(pkg: str, num_parents: int) -> str:
+    if num_parents == 0:
+        return pkg
+    segments = pkg.split(".")
+    return ".".join(segments[:-num_parents])
+
+
+def resolve_maybe_relative(mod: str, stack_depth: int = 1) -> ModuleType:
+    """
+    Resolve a module, maybe relative to the stack frame and import it.
+
+    :param mod: the module to import. starts with a dot if it is relative.
+    :param stack_depth: relative to which module in the stack.
+        used to do an api that call it instead of resolve the module directly.
+    :return: the imported module
+    """
+    if mod.startswith("."):
+        caller_module = inspect.getmodule(inspect.stack()[stack_depth][0])
+        # we could do an assert here but caller_module could really be none ?
+        parent_module = resolve_package(caller_module)  # type: ignore
+        package = parent_module.__name__
+        mod, count = _strip_left_dots(mod)
+        package = _get_parent(package, count)
+        mod = f"{package}.{mod}".rstrip(".")
+
+    module = importlib.import_module(mod)
+    return module

fastlife/testing/dom.py

@@ -0,0 +1,140 @@
+"""Class utilities to access to the DOM."""
+
+import re
+from collections.abc import Iterator, Sequence
+from typing import TYPE_CHECKING
+
+import bs4
+
+if TYPE_CHECKING:
+    from .testclient import WebResponse, WebTestClient  # coverage: 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) -> str | None:
+        """
+        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:
+                ret = el.attrs["hx-target"]
+                if ret == "this":
+                    ret = el.attrs["id"]
+                return ret
+            el = el.parent
+        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):
+                node = node.parent
+
+            if node_name:
+                while node is not None:
+                    if node.name == node_name:
+                        yield Element(self._client, node)
+                    node = node.parent
+            elif node:
+                yield Element(self._client, node)
+        return None
+
+    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
+        resp = self._tag.find(id=label.attrs["for"])
+        assert not isinstance(resp, bs4.NavigableString)
+        return Element(self._client, resp) if resp else None
+
+    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 {})
+        ]
+
+    def __repr__(self) -> str:
+        return f"<{self.node_name}>"
+
+    def __str__(self) -> str:
+        return str(self._tag)