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

CHANGELOG.md

@@ -0,0 +1,202 @@
+## 0.19.0  - Released on 2024-11-07
+* Drop Babel from depenencies for i18n, rely on GNUTranslations only
+* Change License to MIT
+* Replace poetry by uv/pdm
+* Update CI workflows
+
+## 0.18.0  - Released on 2024-10-13
+* Make the sphinx pluging {mod}`fastlife.adapters.jinjax.jinjax_ext.jinjax_doc`
+  parts from the API in order to let users build their own component documentation.
+
+## 0.17.0  - Released on 2024-10-08
+* Fix @configure decorator signature for GenericConfigurator
+* Breaking change - rename Configurator.set_open_tag to Configurator.set_openapi_tag
+
+## 0.16.4  - Released on 2024-10-04
+* Add support of x-real-port for port detection, fallback port to 0 instead of None if missing
+
+## 0.16.3  - Released on 2024-10-03
+* Fix middleware that process the x-forwarded-headers to respect ASGI spec for client
+
+## 0.16.2  - Released on 2024-10-03
+* Add a new property all_registered_permissions on the Configurator class
+
+## 0.16.1  - Released on 2024-10-03
+* Fix import in the SecurityPolicy that make it unusable.
+
+## 0.16.0  - Released on 2024-10-02
+* Make the Configurator, Request and Registry Generic.
+* Breaking change, remove settings `api_swagger_ui_url` and `api_redoc_url`
+  now to register those url, use
+  {meth}`fastlife.config.configurator.GenericConfigurator.set_api_documentation_info`
+* Breaking change, in the method
+  {meth}`fastlife.config.configurator.GenericConfigurator.set_api_documentation_info`
+  summary is now kwargs only.
+
+## 0.15.1  - Released on 2024-09-29
+* Hotfix components to create tables
+
+## 0.15.0  - Released on 2024-09-29
+* Add an {class}`fastlife.security.policy.AbstractSecurityPolicy` class
+* New method {meth}`fastlife.config.configurator.GenericConfigurator.set_security_policy`
+* Breaking change, the check_permission has been removed from the settings.
+  to configure the permission policy, a security policy has to be implemented.
+
+## 0.14.0  - Released on 2024-09-26
+* Implemement method add_template_search_path in the configurator
+* Add a route_prefix in the configurator for configurator.include
+
+## 0.13.0  - Released on 2024-09-25
+* Add a way to handle api
+* Add a @view_config decorator to register route
+* Add a @resource decorator to handle CRUD resource in rest format
+* Add @exception_handler decorator
+* Add i18n support
+
+## 0.12.0  - Released on 2024-09-19
+* Add a way to register API routes and expose api doc
+
+## 0.11.1  - Released on 2024-09-18
+* Update FastAPI version
+
+## 0.11.0  - Released on 2024-09-18
+* Huge documentation update
+  * Use sphinx-autodoc2
+  * Add documentation for the components.
+* Breaking change in the configurator.
+  * get_app has been renamed get_asgi_app
+  * a few internals classes moved/renamed.
+
+## 0.10.0  - Released on 2024-08-24
+
+* Rename model_result and ModelResult to form_model and FormModel
+* Add an edit method for FormModel
+* Add a Textarea widget and fix Hidden widget
+* Fix rendering of sequence
+* Do not render main form as nested models
+* Add many functional tests for form field generations
+
+## 0.9.7  - Released on 2024-08-21
+
+* Add title attribute to icons
+
+## 0.9.6  - Released on 2024-08-18
+
+* Add more buttons options for htmx ajax call
+* Fix Option id
+
+## 0.9.5  - Released on 2024-08-17
+
+* Use icons to customize collapsible widget for sequence
+* Add parameter for button to avoid send params
+
+## 0.9.4  - Released on 2024-08-16
+
+* Don't update browser url while manipulating autoform lists
+
+## 0.9.3  - Released on 2024-08-16
+
+* Fix autoform widgets from jinjax migration
+
+## 0.9.2  - Released on 2024-08-13
+
+* Add a constants class for global variable in templates
+* Use icons to customize collapsible widget
+
+## 0.9.1  - Released on 2024-08-12
+
+* Replace fa icons by hero icons
+
+## 0.9.0  - Released on 2024-08-12
+
+* Add fa Icons (extra)
+
+## 0.8.0  - Released on 2024-08-10
+
+* Upgrade JinjaX (Template update required, use vue-like syntax now)
+
+## 0.7.3  - Released on 2024-08-10
+
+* Add some HTML markup
+
+## 0.7.2  - Released on 2024-08-07
+
+* Fix https behind a reverse proxy
+
+## 0.7.1  - Released on 2024-08-04
+
+* Add the registry on request for exception handler
+
+## 0.7.0  - Released on 2024-08-04
+
+* Rewrite how the registry is handled, now part of the request (request.registry)
+* Update to get hx-confirm and hx-delete on button
+
+## 0.6.1  - Released on 2024-04-27
+
+* Display errors on every widget
+
+## 0.6.0  - Released on 2024-04-25
+
+* Refactor the pydantic_form to start handling errors in form.
+
+## 0.5.1  - Released on 2024-04-24
+
+* Fix minimum dependency version for JinjaX
+
+## 0.5.0  - Released on 2024-04-24
+
+* Implement new types for pydantic form: Enum, Set[Literal] and Set[Enum]
+
+## 0.4.1  - Released on 2024-04-20
+
+* Add globals to render custom widget with global data
+
+## 0.4.0  - Released on 2024-04-20
+
+* Update JinjaX for global template var support
+* Add lots of missing unit tests
+* Add support of more html form element
+* Update deps
+
+## 0.3.1  - Released on 2024-03-29
+
+* Update FastAPI
+
+## 0.3.0  - Released on 2024-03-29
+
+* Replace jinja2 by JinjaX
+
+## 0.2.3  - Released on 2024-01-29
+
+* Add support of relative import in :class:`Configurator.include` method
+
+## 0.2.2  - Released on 2024-01-28
+
+* Add another settings for session domain cookie
+* Update test client wrapper and also wrap bs4 tag
+* Fix session cleanup to properly logout
+
+## 0.2.1  - Released on 2024-01-27
+
+* Change add_route signature
+  * Set the name of the route mandatory and first argument (breaking change)
+  * Add a permission argument
+  * Add a settings to inject a check_permission handler
+
+## 0.2.0  - Released on 2024-01-24
+
+* Add a session wrapper in the test client
+  Allows to initialize session data in tests
+
+## 0.1.2  - Released on 2024-01-15
+
+* Handle sessions
+
+## 0.1.1  - Released on 2024-01-05
+
+* Update fastapi depencency
+
+## 0.1.0  - Released on 2024-01-05
+
+* Initial release

fastlife/__init__.py

@@ -1,3 +1,7 @@
+from importlib import metadata
+
+__version__ = metadata.version("fastlifeweb")
+
 from fastapi import Response
 
 from .config import (

fastlife/adapters/jinjax/__init__.py

@@ -1,7 +1,7 @@
 """Main template renderer based on JinjaX."""
 
-from .renderer import JinjaxTemplateRenderer
+from .renderer import JinjaxEngine
 
 __all__ = [
-    "JinjaxTemplateRenderer",
+    "JinjaxEngine",
 ]

fastlife/adapters/jinjax/jinjax_ext/__init__.py

@@ -0,0 +1 @@
+"""JinjaX extention to support introspection."""

fastlife/adapters/jinjax/jinjax_ext/docstring.py

@@ -0,0 +1,77 @@
+"""
+Template rending based on JinjaX.
+"""
+
+import ast
+import textwrap
+from typing import Any
+
+
+def generate_docstring(
+    func_def: ast.FunctionDef, component_name: str, add_content: bool
+) -> str:
+    """Generate a docstring for a JinjaX 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"
+    )

fastlife/adapters/jinjax/jinjax_ext/inspectable_catalog.py

@@ -0,0 +1,85 @@
+"""
+Template rending based on JinjaX.
+"""
+
+import logging
+import re
+from collections.abc import Iterator, Sequence
+
+from jinja2.exceptions import TemplateSyntaxError
+from jinjax import DuplicateDefDeclaration, InvalidArgument
+from jinjax.catalog import Catalog
+
+from .inspectable_component import InspectableComponent
+
+log = logging.getLogger(__name__)
+
+
+def to_include(
+    name: str,
+    ignores: Sequence[re.Pattern[str]] | None = None,
+    includes: Sequence[re.Pattern[str]] | None = None,
+) -> bool:
+    if includes and not any(include.match(name) for include in includes):
+        return False
+
+    if ignores and any(ignore.match(name) for ignore in ignores):
+        return False
+
+    return True
+
+
+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
+                )
+                is_included = to_include(name, ignores, includes)
+                if is_included:
+                    try:
+                        component = InspectableComponent(
+                            name=name, prefix=prefix, path=path, source=path.read_text()
+                        )
+                    except InvalidArgument as exc:
+                        log.error(f"Definition Syntax Error in <{name}/>: {exc}")
+                        log.error(path.read_text())
+                        continue
+                    except DuplicateDefDeclaration as exc:
+                        log.error(f"Duplicate Definition in <{name}/>: {exc}")
+                        log.error(path.read_text())
+                        continue
+
+                    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"Template Syntax Error in <{name}/>: {exc} on "
+                            "{exc.lineno} :"
+                        )
+                        log.error(path.read_text())
+                        continue
+                    yield component

fastlife/adapters/jinjax/jinjax_ext/inspectable_component.py

@@ -0,0 +1,112 @@
+"""
+Template rending based on JinjaX.
+"""
+
+import ast
+import logging
+import re
+from pathlib import Path
+from typing import cast
+
+from jinja2 import Template
+from jinjax.component import RX_ARGS_START, RX_META_HEADER, Component
+
+from .docstring import generate_docstring
+
+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"{#[^#]+#}")
+
+
+SIGNATURE = """
+def component({args}):
+    '''
+    {docstring}
+    '''
+    ...
+"""
+
+
+def has_content(source: str) -> bool:
+    nocomment = RX_COMMENT_REPLACE.sub("", source)
+    return len(RX_CONTENT.findall(nocomment)) > 0
+
+
+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]
+            docstring = ""
+
+            expr = None
+            while header:
+                item = header.pop(0).strip(" -\n")
+
+                expr = self.read_metadata_item(item, RX_ARGS_START)  # type: ignore
+                doc = self.read_metadata_item(item, RX_DOC_START)  # type: ignore
+                if doc:
+                    docstring += f"    {doc.strip()}\n"
+                    continue
+
+            sigargs = f"*, {expr}" if expr else ""
+            signature = SIGNATURE.format(args=sigargs, docstring=docstring or "")
+
+        astree = ast.parse(signature)
+        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