fastlifeweb 0.21.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.22.0  - Released on 2024-11-23
+* Add a way to add fatal errors on form in order to display an error block.
+* The localizer can be called gettext in the depency in order to simple translation.
+* Expose the 99% of the usefull API in the main package.
+* Refactor all internal class to get a more hexagonal approach in order to reduce
+  circular dependencies.
+
 ## 0.21.0  - Released on 2024-11-15
 * Make the InlineTemplate the only way to render views template.
   * Breaking change: template args is not supported in Configutor.add_route.
@@ -51,7 +58,7 @@
 * Hotfix components to create tables
 
 ## 0.15.0  - Released on 2024-09-29
-* Add an {class}`fastlife.security.policy.AbstractSecurityPolicy` class
+* Add an {class}`fastlife.service.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.

fastlife/__init__.py

@@ -5,43 +5,70 @@ __version__ = metadata.version("fastlifeweb")
 from fastapi import Response
 from fastapi.responses import RedirectResponse
 
+from .adapters.fastapi.form import form_model
+from .adapters.fastapi.localizer import Localizer
+from .adapters.fastapi.request import AnyRequest, Registry, Request, get_request
 from .config import (
     Configurator,
-    DefaultRegistry,
     GenericConfigurator,
-    GenericRegistry,
-    Settings,
     configure,
+    exception_handler,
     resource,
     resource_view,
     view_config,
 )
+from .domain.model.form import FormModel
+from .domain.model.request import GenericRequest
+from .domain.model.security_policy import (
+    Allowed,
+    Denied,
+    Forbidden,
+    HasPermission,
+    Unauthenticated,
+    Unauthorized,
+)
 from .domain.model.template import JinjaXTemplate
-from .request import GenericRequest, Registry, Request, get_request
 
 # from .request.form_data import model
-from .services.templates import TemplateParams
+from .service.registry import DefaultRegistry, GenericRegistry
+from .service.security_policy import AbstractSecurityPolicy, InsecurePolicy
+from .settings import Settings
 
 __all__ = [
     # Config
-    "configure",
     "GenericConfigurator",
-    "Configurator",
-    "DefaultRegistry",
     "GenericRegistry",
-    "TemplateParams",
+    "Registry",
     "Settings",
+    "configure",
     "view_config",
+    "exception_handler",
     "resource",
     "resource_view",
-    # Model
-    # "model",
-    "Request",
+    "Configurator",
+    "DefaultRegistry",
+    # Form
+    "FormModel",
+    "form_model",
+    # Request
     "GenericRequest",
+    "AnyRequest",
+    "Request",
     "get_request",
-    "Registry",
+    # Response
     "Response",
     "RedirectResponse",
+    # Security
+    "AbstractSecurityPolicy",
+    "HasPermission",
+    "Unauthenticated",
+    "Allowed",
+    "Denied",
+    "Unauthorized",
+    "Forbidden",
+    "InsecurePolicy",
     # Template
     "JinjaXTemplate",
+    # i18n
+    "Localizer",
 ]

fastlife/adapters/__init__.py

@@ -1,3 +1,3 @@
 """
-Adapters are implementations of abstract classed defined in {mod}`fastlife.services`.
+Adapters are implementations of abstract classed defined in {mod}`fastlife.service`.
 """

fastlife/adapters/fastapi/__init__.py

@@ -0,0 +1,9 @@
+"""
+Adapters based on top of FastAPI.
+
+At the momdent, the code is highly coupled with FastAPI,
+some part of the code import fastapi directly for legacy reason,
+but it shouldn't.
+
+All FastAPI dependency should be contained in this module.
+"""

fastlife/adapters/fastapi/form.py

@@ -0,0 +1,26 @@
+"""HTTP Form serialization."""
+
+from collections.abc import Callable, Mapping
+from typing import Any
+
+from fastapi import Depends
+
+from fastlife.adapters.fastapi.form_data import MappingFormData
+from fastlife.adapters.fastapi.request import Registry
+from fastlife.domain.model.form import FormModel, T
+
+
+def form_model(
+    cls: type[T], name: str | None = None
+) -> Callable[[Mapping[str, Any]], FormModel[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) -> FormModel[T]:
+        prefix = name or registry.settings.form_data_model_prefix
+        if not data:
+            return FormModel[T].default(prefix, cls)
+        return FormModel[T].from_payload(prefix, cls, data)
+
+    return Depends(to_model)

fastlife/{request → adapters/fastapi}/form_data.py

@@ -10,7 +10,7 @@ from typing import (
 
 from fastapi import Depends
 
-from fastlife import Request
+from fastlife.adapters.fastapi.request import Request
 
 
 def unflatten_struct(

fastlife/{request → adapters/fastapi}/localizer.py

@@ -2,12 +2,14 @@ from typing import Annotated
 
 from fastapi import Depends
 
-from fastlife.request.request import Request
-from fastlife.services.translations import Localizer as RequestLocalizer
+from fastlife.adapters.fastapi.request import Request
+from fastlife.service.translations import Localizer as RequestLocalizer
 
 
 def get_localizer(request: Request) -> RequestLocalizer:
+    """Return the localizer for the given request."""
     return request.registry.localizer(request)
 
 
 Localizer = Annotated[RequestLocalizer, Depends(get_localizer)]
+"""Define a localizer"""

fastlife/adapters/fastapi/request.py

@@ -0,0 +1,33 @@
+"""HTTP Request representation in a python object."""
+
+from typing import Annotated, Any
+
+from fastapi import Request as FastAPIRequest
+from fastapi.params import Depends
+
+from fastlife.domain.model.request import GenericRequest
+from fastlife.service.registry import DefaultRegistry
+
+
+def get_request(request: FastAPIRequest) -> GenericRequest[Any]:
+    """Return the Fastlife Request object."""
+    return request  # type: ignore
+
+
+Request = Annotated[GenericRequest[DefaultRegistry], Depends(get_request)]
+"""A request that is associated to the default registry."""
+# FastAPI handle its Request objects using a lenient_issubclass,
+# basically a issubclass(Request), doe to the Generic[T], it does not work.
+
+
+AnyRequest = Annotated[GenericRequest[Any], Depends(get_request)]
+"""A request version that is associated to the any registry."""
+
+
+def get_registry(request: Request) -> DefaultRegistry:
+    """Return the Fastlife Registry object."""
+    return request.registry
+
+
+Registry = Annotated[DefaultRegistry, Depends(get_registry)]
+"""FastAPI dependency to access to the global registry."""

fastlife/{routing → adapters/fastapi/routing}/route.py

@@ -7,10 +7,10 @@ from fastapi.routing import APIRoute
 from starlette.requests import Request as StarletteRequest
 from starlette.responses import Response
 
-from fastlife.request.request import Request
+from fastlife.domain.model.request import GenericRequest
 
 if TYPE_CHECKING:
-    from fastlife.config.registry import DefaultRegistry  # coverage: ignore
+    from fastlife.service.registry import DefaultRegistry  # coverage: ignore
 
 
 class Route(APIRoute):
@@ -41,7 +41,7 @@ class Route(APIRoute):
         orig_route_handler = super().get_route_handler()
 
         async def route_handler(request: StarletteRequest) -> Response:
-            req = Request(self._registry, request)
+            req = GenericRequest(self._registry, request)
             return await orig_route_handler(req)
 
         return route_handler

fastlife/{routing → adapters/fastapi/routing}/router.py

@@ -9,7 +9,7 @@ from typing import Any
 
 from fastapi import APIRouter
 
-from fastlife.routing.route import Route
+from fastlife.adapters.fastapi.routing.route import Route
 
 
 class Router(APIRouter):

fastlife/adapters/itsdangerous/__init__.py

@@ -0,0 +1,3 @@
+from .session import SignedSessionSerializer
+
+__all__ = ["SignedSessionSerializer"]

fastlife/adapters/itsdangerous/session.py

@@ -0,0 +1,50 @@
+"""Serialize session."""
+
+import json
+from base64 import b64decode, b64encode
+from collections.abc import Mapping
+from typing import Any
+
+import itsdangerous
+
+from fastlife.middlewares.session.serializer import AbsractSessionSerializer
+
+
+class SignedSessionSerializer(AbsractSessionSerializer):
+    """
+    The default fastlife session serializer.
+
+    It's based on the itsdangerous package to sign the session with a secret key.
+
+    :param secret_key: a secret used to sign the session payload.
+
+    :param max_age: session lifetime in seconds.
+    """
+
+    def __init__(self, secret_key: str, max_age: int) -> None:
+        self.signer = itsdangerous.TimestampSigner(secret_key)
+        self.max_age = max_age
+
+    def serialize(self, data: Mapping[str, Any]) -> bytes:
+        """Serialize and sign the session."""
+        dump = json.dumps(data).encode("utf-8")
+        encoded = b64encode(dump)
+        signed = self.signer.sign(encoded)
+        return signed
+
+    def deserialize(self, data: bytes) -> tuple[Mapping[str, Any], bool]:
+        """Deserialize the session.
+
+        If the signature is incorect, the session restart from the begining.
+        No exception raised.
+        """
+        try:
+            data = self.signer.unsign(data, max_age=self.max_age)
+            # We can't deserialize something wrong since the serialize
+            # is signing the content.
+            # If the signature key is compromise and we have invalid payload,
+            # raising exceptions here is fine, it's dangerous afterall.
+            session = json.loads(b64decode(data))
+        except itsdangerous.BadSignature:
+            return {}, True
+        return session, False

fastlife/adapters/jinjax/jinjax_ext/inspectable_component.py

@@ -42,17 +42,17 @@ class InspectableComponent(Component):
     """
 
     __slots__ = (
-        "name",
-        "prefix",
-        "url_prefix",
-        "required",
-        "optional",
         "css",
         "js",
-        "path",
         "mtime",
-        "tmpl",
+        "name",
+        "optional",
+        "path",
+        "prefix",
+        "required",
         "source",
+        "tmpl",
+        "url_prefix",
     )
 
     def __init__(

fastlife/adapters/jinjax/jinjax_ext/jinjax_doc.py

@@ -14,7 +14,7 @@ from sphinx.roles import XRefRole
 from sphinx.util import relative_uri  # type: ignore
 
 from fastlife.adapters.jinjax.renderer import JinjaxEngine
-from fastlife.config.settings import Settings
+from fastlife.settings import Settings
 
 
 def create_ref_node(arg_type: str) -> nodes.Node:

fastlife/adapters/jinjax/renderer.py

@@ -14,15 +14,15 @@ from markupsafe import Markup
 from pydantic.fields import FieldInfo
 
 from fastlife import Request
+from fastlife.adapters.fastapi.form import FormModel
+from fastlife.adapters.fastapi.localizer import get_localizer
 from fastlife.adapters.jinjax.widget_factory.factory import WidgetFactory
-from fastlife.request.form import FormModel
-from fastlife.request.localizer import get_localizer
-from fastlife.templates.inline import InlineTemplate
+from fastlife.domain.model.template import InlineTemplate
 
 if TYPE_CHECKING:
-    from fastlife.config.settings import Settings  # coverage: ignore
+    from fastlife.settings import Settings  # coverage: ignore
 
-from fastlife.services.templates import (
+from fastlife.service.templates import (
     AbstractTemplateRenderer,
     AbstractTemplateRendererFactory,
 )

fastlife/adapters/jinjax/widget_factory/factory.py

@@ -10,10 +10,11 @@ from markupsafe import Markup
 from pydantic.fields import FieldInfo
 
 from fastlife.adapters.jinjax.widgets.base import CustomWidget, Widget
-from fastlife.request.form import FormModel
+from fastlife.domain.model.form import FormModel
+from fastlife.domain.model.template import JinjaXTemplate
 
 if TYPE_CHECKING:
-    from fastlife.services.templates import AbstractTemplateRenderer
+    from fastlife.service.templates import AbstractTemplateRenderer
 
 from .base import BaseWidgetBuilder
 from .bool_builder import BoolBuilder
@@ -28,6 +29,11 @@ from .simpletype_builder import SimpleTypeBuilder
 from .union_builder import UnionBuilder
 
 
+class FatalError(JinjaXTemplate):
+    template = """<pydantic_form.FatalError :message="message" />"""
+    message: str
+
+
 class WidgetFactory:
     """
     Form builder for pydantic model.
@@ -71,7 +77,10 @@ class WidgetFactory:
         :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(
+        ret = Markup()
+        if model.fatal_error:
+            ret += self.renderer.render_template(FatalError(message=model.fatal_error))
+        ret += self.get_widget(
             model.model.__class__,
             model.form_data,
             model.errors,
@@ -79,6 +88,7 @@ class WidgetFactory:
             removable=removable,
             field=field,
         ).to_html(self.renderer)
+        return ret
 
     def get_widget(
         self,

fastlife/adapters/jinjax/widgets/base.py

@@ -8,7 +8,7 @@ from markupsafe import Markup
 from pydantic import Field, model_validator
 
 from fastlife.domain.model.template import JinjaXTemplate
-from fastlife.services.templates import AbstractTemplateRenderer
+from fastlife.service.templates import AbstractTemplateRenderer
 from fastlife.shared_utils.infer import is_union
 
 T = TypeVar("T")

fastlife/adapters/jinjax/widgets/model.py

@@ -5,7 +5,7 @@ from collections.abc import Sequence
 from markupsafe import Markup
 from pydantic import Field
 
-from fastlife.services.templates import AbstractTemplateRenderer
+from fastlife.service.templates import AbstractTemplateRenderer
 
 from .base import TWidget, Widget
 

fastlife/adapters/jinjax/widgets/sequence.py

@@ -4,7 +4,7 @@ from typing import Any
 from markupsafe import Markup
 from pydantic import Field
 
-from fastlife.services.templates import AbstractTemplateRenderer
+from fastlife.service.templates import AbstractTemplateRenderer
 
 from .base import TWidget, TypeWrapper, Widget
 

fastlife/adapters/jinjax/widgets/union.py

@@ -8,7 +8,7 @@ from typing import Union
 from markupsafe import Markup
 from pydantic import BaseModel, Field
 
-from fastlife.services.templates import AbstractTemplateRenderer
+from fastlife.service.templates import AbstractTemplateRenderer
 
 from .base import TWidget, TypeWrapper, Widget
 

fastlife/components/Form.jinja

@@ -2,7 +2,7 @@
   Create html ``<form>`` node with htmx support by default.
   A :jinjax:component:`CsrfToken` will always be included in the form
   and will be checked by the
-  :func:`csrf policy method <fastlife.security.csrf.check_csrf>`.
+  :func:`csrf policy method <fastlife.service.csrf.check_csrf>`.
 
   ::
 

fastlife/components/pydantic_form/FatalError.jinja

@@ -0,0 +1,8 @@
+{# doc display an error for a field. #}
+{# def message: Annotated[str | None, "error message"] #}
+{%- if message -%}
+<div class="flex items-center bg-red-50 border border-red-400 text-red-700" role="alert">
+  <icons.Fire class="m-3 w-16 h-16 fill-orange-500" />
+  <span class="sm:inline text-xl">{{ message }}</span>
+</div>
+{%- endif -%}

fastlife/config/__init__.py

@@ -1,19 +1,16 @@
 """Configure fastlife app for dependency injection."""
 
 from .configurator import Configurator, GenericConfigurator, configure
-from .registry import DefaultRegistry, GenericRegistry
+from .exceptions import exception_handler
 from .resources import resource, resource_view
-from .settings import Settings
 from .views import view_config
 
 __all__ = [
     "Configurator",
     "GenericConfigurator",
     "configure",
-    "view_config",
+    "exception_handler",
     "resource",
     "resource_view",
-    "GenericRegistry",
-    "DefaultRegistry",
-    "Settings",
+    "view_config",
 ]

fastlife/config/configurator.py

@@ -27,27 +27,29 @@ from fastapi.params import Depends as DependsType
 from fastapi.staticfiles import StaticFiles
 from fastapi.types import IncEx
 
+from fastlife.adapters.fastapi.request import GenericRequest, Request
+from fastlife.adapters.fastapi.routing.route import Route
+from fastlife.adapters.fastapi.routing.router import Router
 from fastlife.config.openapiextra import OpenApiTag
+from fastlife.domain.model.template import InlineTemplate
 from fastlife.middlewares.base import AbstractMiddleware
-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, resolve_maybe_relative
-from fastlife.templates.inline import is_inline_template_returned
-
-from .registry import DefaultRegistry, TRegistry
-from .settings import Settings
+from fastlife.service.check_permission import check_permission
+from fastlife.service.csrf import check_csrf
+from fastlife.service.registry import DefaultRegistry, TRegistry
+from fastlife.settings import Settings
+from fastlife.shared_utils.infer import is_inline_template_returned
+from fastlife.shared_utils.resolver import (
+    resolve,
+    resolve_maybe_relative,
+)
 
 if TYPE_CHECKING:
-    from fastlife.security.policy import AbstractSecurityPolicy  # coverage: ignore
-    from fastlife.services.templates import (
+    from fastlife.service.security_policy import AbstractSecurityPolicy
+    from fastlife.service.templates import (
         AbstractTemplateRendererFactory,  # coverage: ignore
     )
-    from fastlife.templates.inline import InlineTemplate
 
-from fastlife.services.locale_negociator import LocaleNegociator
+from fastlife.service.locale_negociator import LocaleNegociator
 
 log = logging.getLogger(__name__)
 VENUSIAN_CATEGORY = "fastlife"
@@ -519,7 +521,7 @@ class GenericConfigurator(Generic[TRegistry]):
             parameters.
         :param endpoint: the function that will reveive the request.
         :param permission: a permission to validate by the
-            {class}`Security Policy <fastlife.security.policy.AbstractSecurityPolicy>`.
+            {class}`Security Policy <fastlife.service.security_policy.AbstractSecurityPolicy>`.
         :param status_code: customize response status code.
         :param methods: restrict route to a list of http methods.
         :return: the configurator.

fastlife/config/resources.py

@@ -170,8 +170,7 @@ def resource_view(
     `collection_head`, `collection_options`, `get`, `post`, `put`, `patch`, `delete`,
     `head` or `options`.
 
-    :param permission: a permission to validate by the
-        :attr:`fastlife.config.settings.Settings.check_permission` function.
+    :param permission: a permission to validate by the security policy.
     :param status_code: returned status_code
     :param summary: OpenAPI summary for the route.
     :param description:OpenAPI description for the route.

fastlife/config/views.py

@@ -45,9 +45,9 @@ def view_config(
     :param path: path of the route, use `{curly_brace}` to inject FastAPI Path
         parameters.
     :param template: the template rendered by the
-        {class}`fastlife.services.templates.AbstractTemplateRenderer`.
+        {class}`fastlife.service.templates.AbstractTemplateRenderer`.
     :param permission: a permission to validate by the
-        {class}`Security Policy <fastlife.security.policy.AbstractSecurityPolicy>`.
+        {class}`Security Policy <fastlife.service.security_policy.AbstractSecurityPolicy>`.
     :param status_code: customize response status code.
     :param methods: restrict route to a list of http methods.
 

fastlife/domain/model/asgi.py

@@ -0,0 +1,3 @@
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
+
+__all__ = ["ASGIApp", "Message", "Receive", "Scope", "Send"]

fastlife/{request → domain/model}/form.py

@@ -1,13 +1,10 @@
 """HTTP Form serialization."""
 
-from collections.abc import Callable, Mapping
+from collections.abc import Mapping
 from typing import Any, Generic, TypeVar, get_origin
 
-from fastapi import Depends
 from pydantic import BaseModel, ValidationError
 
-from fastlife import Registry
-from fastlife.request.form_data import MappingFormData
 from fastlife.shared_utils.infer import is_union
 
 T = TypeVar("T", bound=BaseModel)
@@ -17,14 +14,16 @@ T = TypeVar("T", bound=BaseModel)
 class FormModel(Generic[T]):
     prefix: str
     model: T
-    errors: Mapping[str, str]
+    fatal_error: str
+    errors: dict[str, str]
     is_valid: bool
 
     def __init__(
-        self, prefix: str, model: T, errors: Mapping[str, Any], is_valid: bool = False
+        self, prefix: str, model: T, errors: dict[str, Any], is_valid: bool = False
     ) -> None:
         self.prefix = prefix
         self.model = model
+        self.fatal_error = ""
         self.errors = errors
         self.is_valid = is_valid
 
@@ -32,6 +31,14 @@ class FormModel(Generic[T]):
     def default(cls, prefix: str, pydantic_type: type[T]) -> "FormModel[T]":
         return cls(prefix, pydantic_type.model_construct(), {})
 
+    def set_fatal_error(self, value: str) -> None:
+        self.fatal_error = value
+        self.is_valid = False
+
+    def add_error(self, field: str, value: str) -> None:
+        self.errors[f"{self.prefix}.{field}"] = value
+        self.is_valid = False
+
     def edit(self, pydantic_type: T) -> None:
         """
         Load the form with the given model and consider it as valid for the user.
@@ -86,19 +93,3 @@ class FormModel(Generic[T]):
                     errors[loc] = error["msg"]
             model = pydantic_type.model_construct(**data.get(prefix, {}))
             return cls(prefix, model, errors)
-
-
-def form_model(
-    cls: type[T], name: str | None = None
-) -> Callable[[Mapping[str, Any]], FormModel[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) -> FormModel[T]:
-        prefix = name or registry.settings.form_data_model_prefix
-        if not data:
-            return FormModel[T].default(prefix, cls)
-        return FormModel[T].from_payload(prefix, cls, data)
-
-    return Depends(to_model)