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

fastlife/adapters/jinjax/renderer.py

@@ -2,29 +2,18 @@
 Template rending based on JinjaX.
 """
 
-import ast
 import logging
-import re
-import textwrap
-from collections.abc import Iterator, Mapping, MutableMapping, Sequence
-from pathlib import Path
+from collections.abc import Mapping, MutableMapping, Sequence
 from typing import (
     TYPE_CHECKING,
     Any,
-    cast,
 )
 
-from jinja2 import Template
-from jinja2.exceptions import TemplateSyntaxError
-from jinjax import InvalidArgument
-from jinjax.catalog import Catalog
-from jinjax.component import RX_ARGS_START, RX_META_HEADER, Component
-from jinjax.exceptions import DuplicateDefDeclaration
 from markupsafe import Markup
 from pydantic.fields import FieldInfo
 
 from fastlife import Request
-from fastlife.adapters.jinjax.widgets.factory import WidgetFactory
+from fastlife.adapters.jinjax.widget_factory.factory import WidgetFactory
 from fastlife.request.form import FormModel
 from fastlife.request.localizer import get_localizer
 
@@ -37,244 +26,9 @@ from fastlife.services.templates import (
 )
 from fastlife.shared_utils.resolver import resolve, resolve_path
 
-log = logging.getLogger(__name__)
-
-RX_DOC_START = re.compile(r"{#-?\s*doc\s+")
-RX_CONTENT = re.compile(r"\{\{-?\s*content\s*-?\}\}", re.DOTALL)
-RX_COMMENT_REPLACE = re.compile(r"{#[^#]+#}")
-
-
-def has_content(source: str) -> bool:
-    nocomment = RX_COMMENT_REPLACE.sub("", source)
-    return len(RX_CONTENT.findall(nocomment)) > 0
-
-
-def generate_docstring(
-    func_def: ast.FunctionDef, component_name: str, add_content: bool
-) -> str:
-    """Generate a docstring for the component."""
-    # Extract function name and docstring
-    docstring = (ast.get_docstring(func_def, clean=True) or "").strip()
-    if docstring:
-        docstring = textwrap.dedent(docstring)
-        docstring_lines = [line for line in docstring.split("\n")]
-        # Add a newline for separation after the function docstring
-        docstring_lines.append("")
-    else:
-        docstring_lines = []
-
-    component_params: list[str] = []
-
-    # Function for processing an argument and adding its docstring lines
-    def process_arg(arg: ast.arg, default_value: Any = None) -> None:
-        arg_name = arg.arg
-        param_desc = ""
-        # Extract the type annotation (if any)
-        if (
-            isinstance(arg.annotation, ast.Subscript)
-            and isinstance(arg.annotation.value, ast.Name)
-            and arg.annotation.value.id == "Annotated"
-        ):
-            # For Annotated types, we expect the first argument to be the type and
-            # the second to be the description
-            type_annotation = arg.annotation.slice.elts[0]  # type: ignore
-            param_type = ast.unparse(type_annotation)  # type: ignore
-
-            if len(arg.annotation.slice.elts) > 1 and isinstance(  # type: ignore
-                arg.annotation.slice.elts[1],  # type: ignore
-                ast.Constant,  # type: ignore
-            ):
-                param_desc = arg.annotation.slice.elts[1].value  # type: ignore
-        else:
-            # Otherwise, just use the type if available
-            param_type = ast.unparse(arg.annotation) if arg.annotation else "Any"
-
-        # Build the parameter docstring line
-        docstring_lines.append(f":param {arg_name.rstrip('_')}: {param_desc}".strip())
-
-        # Build the string representation of the parameter
-        param_str = f"{arg_name}: {param_type}"
-        if default_value is not None:
-            param_str += f" = {ast.unparse(default_value)}"  # type: ignore
-
-        component_params.append(param_str)
-
-    # Process keyword-only arguments
-    kwonlyargs = func_def.args.kwonlyargs
-    kw_defaults = func_def.args.kw_defaults
-
-    for arg, default in zip(kwonlyargs, kw_defaults, strict=False):
-        process_arg(arg, default)
-
-    if add_content:
-        component_params.append("content: Any")
-        docstring_lines.append(":param content: child node.")
-
-    return (
-        f"{component_name}({', '.join(component_params)})"
-        + "\n"
-        + "\n    "
-        + ("\n    ".join(docstring_lines).strip()).replace("\n    \n", "\n\n")
-        + "\n"
-    )
-
-
-class InspectableComponent(Component):
-    """
-    JinjaX Components override that support intropspection.
-
-    The Component class of JinjaX does not support documentation by default.
-    """
-
-    __slots__ = (
-        "name",
-        "prefix",
-        "url_prefix",
-        "required",
-        "optional",
-        "css",
-        "js",
-        "path",
-        "mtime",
-        "tmpl",
-        "source",
-    )
-
-    def __init__(
-        self,
-        *,
-        name: str,
-        prefix: str = "",
-        url_prefix: str = "",
-        source: str = "",
-        mtime: float = 0,
-        tmpl: "Template | None" = None,
-        path: "Path | None" = None,
-    ) -> None:
-        super().__init__(
-            name=name,
-            prefix=prefix,
-            url_prefix=url_prefix,
-            source=source,
-            mtime=mtime,
-            tmpl=tmpl,
-            path=path,
-        )
-        self.source = source
-
-    def as_def(self) -> ast.FunctionDef:
-        """Return the component definition as a python function definition."""
-        signature = "def component(): pass"
-        match = RX_META_HEADER.match(self.source)
-        if match:
-            headers = match.group(0)
-            header = headers.split("#}")[:-1]
-            def_found = False
-            docstring = ""
-
-            expr = None
-            while header:
-                item = header.pop(0).strip(" -\n")
+from .jinjax_ext.inspectable_catalog import InspectableCatalog
 
-                expr = self.read_metadata_item(item, RX_ARGS_START)  # type: ignore
-                if expr:
-                    if def_found:
-                        raise DuplicateDefDeclaration(self.name)
-                    def_found = True
-                    continue
-
-                doc = self.read_metadata_item(item, RX_DOC_START)  # type: ignore
-                if doc:
-                    docstring += f"    {doc.strip()}\n"
-                    continue
-
-            if expr:
-                signature = f"""\
-def component(*, {expr}):
-    '''
-    {docstring or ""}
-    '''
-    ...
-"""
-            elif docstring:
-                signature = f"""\
-def component():
-    '''
-    {docstring}
-    '''
-    ...
-"""
-
-        try:
-            astree = ast.parse(signature)
-        except SyntaxError as err:
-            raise InvalidArgument(err) from err
-        return cast(ast.FunctionDef, astree.body[0])
-
-    def build_docstring(self) -> str:
-        """Build a rst docstring for the jinjax component."""
-        func_def = self.as_def()
-        prefix = f"{self.prefix}." if self.prefix else ""
-        ret = ".. jinjax:component:: " + generate_docstring(
-            func_def, f"{prefix}{self.name}", has_content(self.source)
-        )
-        return ret
-
-
-class InspectableCatalog(Catalog):
-    """
-    JinjaX Catalog with introspection support.
-
-    Override the catalog in order to iterate over components to build the doc.
-    """
-
-    def iter_components(
-        self,
-        ignores: Sequence[re.Pattern[str]] | None = None,
-        includes: Sequence[re.Pattern[str]] | None = None,
-    ) -> Iterator[InspectableComponent]:
-        """
-        Walk into every templates from the settings, iterate over components.
-
-        :params ignores: filter components using an block list.
-        :params includes: filter components using an allowed list.
-        """
-        for prefix, loader in self.prefixes.items():
-            for t in loader.list_templates():
-                name, file_ext = t.split(".", maxsplit=1)
-                name = name.replace("/", ".")
-                path, tmpl_name = self._get_component_path(
-                    prefix, name, file_ext=file_ext
-                )
-
-                to_include = True
-                if includes:
-                    to_include = False
-                    for include in includes:
-                        if include.match(name):
-                            to_include = True
-                            break
-                if to_include and ignores:
-                    for ignore in ignores:
-                        if ignore.match(name):
-                            to_include = False
-                            break
-
-                if to_include:
-                    component = InspectableComponent(
-                        name=name, prefix=prefix, path=path, source=path.read_text()
-                    )
-
-                    self.jinja_env.loader = loader
-                    try:
-                        component.tmpl = self.jinja_env.get_template(
-                            tmpl_name, globals=self._tmpl_globals
-                        )
-                    except TemplateSyntaxError as exc:
-                        log.error(f"Syntax Error: {exc} on {exc.lineno} :")
-                        log.error(path.read_text())
-                        continue
-                    yield component
+log = logging.getLogger(__name__)
 
 
 def build_searchpath(template_search_path: str) -> Sequence[str]:
@@ -340,6 +94,14 @@ class JinjaxRenderer(AbstractTemplateRenderer):
         globals: Mapping[str, Any] | None = None,
         **params: Any,
     ) -> str:
+        """
+        Render the JinjaX component with the given parameter.
+
+        :param template: the template to render
+        :param globals: parameters that will be used by the JinjaX component and all its
+            child components without "props drilling".
+        :param params: parameters used to render the template.
+        """
         # Jinja template does accept the file extention while rendering the template
         # we strip it before rendering.
         template = template[: -len(self.settings.jinjax_file_ext) - 1]
@@ -357,6 +119,13 @@ class JinjaxRenderer(AbstractTemplateRenderer):
     def pydantic_form(
         self, model: FormModel[Any], *, token: str | None = None
     ) -> Markup:
+        """
+        Generate HTML markup to build a form from the given form model.
+
+        :param model: the form model that will be transformed to markup.
+        :param token: a token used to ensure that unique identifier are unique.
+        :return: HTML Markup generated by composign fields widgets.
+        """
         return WidgetFactory(self, token).get_markup(model)
 
     def pydantic_form_field(
@@ -368,6 +137,17 @@ class JinjaxRenderer(AbstractTemplateRenderer):
         removable: bool,
         field: FieldInfo | None,
     ) -> Markup:
+        """
+        Generate HTML for a particular field in a form.
+
+        This function is used to generate union subtypes in Ajax requests.
+        :param model: a pydantic or python builtin type that is requests to be rendered
+        :param name: name for the field
+        :param token: the token of the form to render unique identifiers
+        :param removable: add a way let the user remove the widget
+        :param field: only render this particular field for the model.
+        :return: HTML Markup.
+        """
         return (
             WidgetFactory(self, token)
             .get_widget(
@@ -382,7 +162,7 @@ class JinjaxRenderer(AbstractTemplateRenderer):
         )
 
 
-class JinjaxTemplateRenderer(AbstractTemplateRendererFactory):
+class JinjaxEngine(AbstractTemplateRendererFactory):
     """
     The default template renderer factory. Based on JinjaX.
 

fastlife/adapters/jinjax/widget_factory/__init__.py

@@ -0,0 +1 @@
+"""Factory for widgets in order to edit pydantic model."""

fastlife/adapters/jinjax/widget_factory/base.py

@@ -0,0 +1,40 @@
+"""Abstract class for builder."""
+
+import abc
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
+
+from pydantic.fields import FieldInfo
+
+from fastlife.adapters.jinjax.widgets.base import Widget
+
+if TYPE_CHECKING:
+    from fastlife.adapters.jinjax.widget_factory.factory import (  # coverage: ignore
+        WidgetFactory,
+    )
+
+T = TypeVar("T")
+
+
+class BaseWidgetBuilder(abc.ABC, Generic[T]):
+    """Base class for the builder of widget."""
+
+    def __init__(self, factory: "WidgetFactory") -> None:
+        self.factory = factory
+
+    @abc.abstractmethod
+    def accept(self, typ: type[Any], origin: type[Any] | None) -> bool:
+        """Return true if the builder accept to build a widget for this type."""
+
+    @abc.abstractmethod
+    def build(
+        self,
+        *,
+        field_name: str,
+        field_type: type[Any],
+        field: FieldInfo | None,
+        value: T | None,
+        form_errors: Mapping[str, Any],
+        removable: bool,
+    ) -> Widget[T]:
+        """Build the widget"""

fastlife/adapters/jinjax/widget_factory/bool_builder.py

@@ -0,0 +1,43 @@
+"""Handle boolean values."""
+
+from collections.abc import Mapping
+from typing import Any
+
+from pydantic.fields import FieldInfo
+
+from fastlife.adapters.jinjax.widget_factory.base import BaseWidgetBuilder
+from fastlife.adapters.jinjax.widgets.boolean import BooleanWidget
+
+
+class BoolBuilder(BaseWidgetBuilder[bool]):
+    """Builder for boolean."""
+
+    def accept(self, typ: type[Any], origin: type[Any] | None) -> bool:
+        """True for boolean."""
+        return issubclass(typ, bool)
+
+    def build(
+        self,
+        *,
+        field_name: str,
+        field_type: type[Any],
+        field: FieldInfo | None,
+        value: bool | None,
+        form_errors: Mapping[str, Any],
+        removable: bool,
+    ) -> BooleanWidget:
+        """Build the widget."""
+        return BooleanWidget(
+            field_name,
+            removable=removable,
+            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=value or False,
+            error=form_errors.get(field_name),
+        )

fastlife/adapters/jinjax/widget_factory/emailstr_builder.py

@@ -0,0 +1,46 @@
+"""Handle EmailStr pydantic type."""
+
+from collections.abc import Mapping
+from typing import Any
+
+from pydantic.fields import FieldInfo
+from pydantic.networks import EmailStr
+
+from fastlife.adapters.jinjax.widget_factory.base import BaseWidgetBuilder
+from fastlife.adapters.jinjax.widgets.text import TextWidget
+
+
+class EmailStrBuilder(BaseWidgetBuilder[EmailStr]):
+    """Builder for Pydantic EmailStr."""
+
+    def accept(self, typ: type[Any], origin: type[Any] | None) -> bool:
+        """True for EmailStr."""
+        return issubclass(typ, EmailStr)  # type: ignore
+
+    def build(
+        self,
+        *,
+        field_name: str,
+        field_type: type[Any],
+        field: FieldInfo | None,
+        value: EmailStr | None,
+        form_errors: Mapping[str, Any],
+        removable: bool,
+    ) -> TextWidget:
+        """Build the widget."""
+        return TextWidget(
+            field_name,
+            input_type="email",
+            placeholder=str(field.examples[0]) if field and field.examples else None,
+            removable=removable,
+            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=str(value),
+            error=form_errors.get(field_name),
+        )

fastlife/adapters/jinjax/widget_factory/enum_builder.py

@@ -0,0 +1,47 @@
+"""Handle Enum type."""
+
+from collections.abc import Mapping
+from enum import Enum
+from typing import Any
+
+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.dropdown import DropDownWidget
+
+
+class EnumBuilder(BaseWidgetBuilder[Enum]):
+    """Builder for Enum."""
+
+    def accept(self, typ: type[Any], origin: type[Any] | None) -> bool:
+        """True for Enum."""
+        return issubclass(typ, Enum)
+
+    def build(
+        self,
+        *,
+        field_name: str,
+        field_type: type[Any],  # an enum subclass
+        field: FieldInfo | None,
+        value: Enum | None,  # str | int | float,
+        form_errors: Mapping[str, Any],
+        removable: bool,
+    ) -> Widget[Enum]:
+        """Build the widget."""
+        options = [(item.name, item.value) for item in field_type]  # type: ignore
+        return DropDownWidget(
+            field_name,
+            options=options,  # type: ignore
+            removable=removable,
+            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=str(value),
+            error=form_errors.get(field_name),
+        )

fastlife/adapters/jinjax/widget_factory/factory.py

@@ -0,0 +1,165 @@
+"""
+Create markup for pydantic forms.
+"""
+
+import secrets
+from collections.abc import Mapping
+from inspect import isclass
+from typing import Any, cast, get_origin
+
+from markupsafe import Markup
+from pydantic.fields import FieldInfo
+
+from fastlife.adapters.jinjax.widgets.base import Widget
+from fastlife.request.form import FormModel
+from fastlife.services.templates import AbstractTemplateRenderer
+
+from .base import BaseWidgetBuilder
+from .bool_builder import BoolBuilder
+from .emailstr_builder import EmailStrBuilder
+from .enum_builder import EnumBuilder
+from .literal_builder import LiteralBuilder
+from .model_builder import ModelBuilder
+from .secretstr_builder import SecretStrBuilder
+from .sequence_builder import SequenceBuilder
+from .set_builder import SetBuilder
+from .simpletype_builder import SimpleTypeBuilder
+from .union_builder import UnionBuilder
+
+
+class WidgetFactory:
+    """
+    Form builder for pydantic model.
+
+    :param renderer: template engine to render widget.
+    :param token: reuse a token.
+    """
+
+    def __init__(self, renderer: AbstractTemplateRenderer, token: str | None = None):
+        self.renderer = renderer
+        self.token = token or secrets.token_urlsafe(4).replace("_", "-")
+        self.builders: list[BaseWidgetBuilder[Any]] = [
+            # Order is super important here
+            # starts by the union type
+            UnionBuilder(self),
+            # and to other types that have an origin
+            SetBuilder(self),
+            LiteralBuilder(self),
+            SequenceBuilder(self),
+            # from this part, order does not really matter
+            ModelBuilder(self),
+            BoolBuilder(self),
+            EnumBuilder(self),
+            EmailStrBuilder(self),
+            SecretStrBuilder(self),
+            # we keep simple types, str, int at the end
+            SimpleTypeBuilder(self),
+        ]
+
+    def get_markup(
+        self,
+        model: FormModel[Any],
+        *,
+        removable: bool = False,
+        field: FieldInfo | None = None,
+    ) -> Markup:
+        """
+        Get the markup for the given model.
+
+        :param model: the model to build the html markup.
+        :param removable: Include a button to remove the model in the markup.
+        :param field: only build the markup of this field is not None.
+        """
+        return self.get_widget(
+            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,
+        field: FieldInfo | None = None,
+    ) -> Widget[Any]:
+        """
+        build the widget for the given type and return it.
+        :param base: the type to build, it has to be a builtin or a Pydantic model.
+        :param form_data: form values to render.
+        :param form_errors: form errors to render.
+        """
+        return self.build(
+            base,
+            value=form_data.get(prefix, {}),
+            form_errors=form_errors,
+            name=prefix,
+            removable=removable,
+            field=field,
+        )
+
+    def build(
+        self,
+        typ: type[Any],
+        *,
+        name: str = "",
+        value: Any,
+        removable: bool,
+        form_errors: Mapping[str, Any],
+        field: FieldInfo | None = None,
+    ) -> Widget[Any]:
+        """
+        build widget tree for the given type.
+        This function is recurive and shoud not be used directly.
+        The type is a composite, it can be pydantic model, builtin, list or unions.
+
+        The {meth}`WidgetFactory.get_widget` or {meth}`WidgetFactory.get_markup`
+        should be used.
+
+        :param typ: the type to build, it has to be a builtin or a Pydantic model.
+        :param name: name of the widget to build.
+        :param value: value for the widget.
+        :param removable: True if it has to include a remove button.
+        :param form_errors: errors in the form.
+        :param field: field information used to customize the widget.
+        """
+        if field and field.metadata:
+            for widget in field.metadata:
+                if isclass(widget) and issubclass(widget, Widget):
+                    return cast(
+                        Widget[Any],
+                        widget(
+                            name,
+                            value=value,
+                            removable=removable,
+                            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.token,
+                            error=form_errors.get(name),
+                        ),
+                    )
+
+        type_origin = get_origin(typ)
+        for builder in self.builders:
+            if builder.accept(typ, type_origin):
+                return builder.build(
+                    field_name=name,
+                    field_type=typ,
+                    field=field,
+                    value=value,
+                    form_errors=form_errors,
+                    removable=removable,
+                )
+
+        raise NotImplementedError(f"{typ} not implemented")  # coverage: ignore