fastlifeweb 0.13.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

fastlife/config/configurator.py

@@ -14,11 +14,12 @@ phase.
 import importlib
 import inspect
 import logging
-from collections.abc import Mapping
+from collections import defaultdict
+from collections.abc import Mapping, Sequence
 from enum import Enum
 from pathlib import Path
 from types import ModuleType
-from typing import TYPE_CHECKING, Annotated, Any, Callable, Self, Tuple, Type, cast
+from typing import TYPE_CHECKING, Annotated, Any, Callable, Self, Tuple, Type
 
 import venusian
 from fastapi import Depends, FastAPI
@@ -27,20 +28,22 @@ from fastapi import Response
 from fastapi.params import Depends as DependsType
 from fastapi.staticfiles import StaticFiles
 from fastapi.types import IncEx
-from pydantic import BaseModel, Field
 
+from fastlife.config.openapiextra import OpenApiTag
 from fastlife.middlewares.base import AbstractMiddleware
 from fastlife.request.request import 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 .settings import Settings
 
 if TYPE_CHECKING:
+    from fastlife.security.policy import AbstractSecurityPolicy  # coverage: ignore
     from fastlife.services.templates import (
-        AbstractTemplateRendererFactory,  # coverage: ignore; coverage: ignore
+        AbstractTemplateRendererFactory,  # coverage: ignore
     )
 
     from .registry import AppRegistry, LocaleNegociator  # coverage: ignore
@@ -48,6 +51,8 @@ if TYPE_CHECKING:
 log = logging.getLogger(__name__)
 VENUSIAN_CATEGORY = "fastlife"
 
+venusian_ignored_item = str | Callable[[str], bool]
+
 
 class ConfigurationError(Exception):
     """
@@ -55,24 +60,53 @@ class ConfigurationError(Exception):
     """
 
 
-class ExternalDocs(BaseModel):
-    """OpenAPI externalDocs object."""
+def rebuild_router(router: Router) -> Router:
+    """
+    Fix the router.
 
-    description: str
-    """link's description."""
-    url: str
-    """link's URL."""
+    FastAPI routers has dependencies that are injected to routes where they are added.
 
+    It means that if you add a dependencies in the router after the route has
+    been added, then the dependencies is missing in the route added before.
 
-class OpenApiTag(BaseModel):
-    """OpenAPI tag object."""
+    To prenvents issues, we rebuild the router route with the dependency.
 
-    name: str
-    """name of the tag."""
-    description: str
-    """explanation of the tag."""
-    external_docs: ExternalDocs | None = Field(alias="externalDocs", default=None)
-    """external link to the doc."""
+    :param router: the router to rebuild
+    :return: a new router with fixed routes.
+    """
+    if not router.dependencies:
+        return router
+    _router = Router(prefix=router.prefix)
+    _router.dependencies = router.dependencies
+    route: Route
+    for route in router.routes:  # type: ignore
+        dependencies = [
+            dep for dep in route.dependencies if dep not in _router.dependencies
+        ]
+        _router.add_api_route(
+            path=route.path,
+            endpoint=route.endpoint,
+            response_model=route.response_model,
+            status_code=route.status_code,
+            tags=route.tags,
+            dependencies=dependencies,
+            summary=route.summary,
+            description=route.description,
+            response_description=route.response_description,
+            deprecated=route.deprecated,
+            methods=route.methods,
+            operation_id=route.operation_id,
+            response_model_include=route.response_model_include,
+            response_model_exclude=route.response_model_exclude,
+            response_model_by_alias=route.response_model_by_alias,
+            response_model_exclude_unset=route.response_model_exclude_unset,
+            response_model_exclude_defaults=route.response_model_exclude_defaults,
+            response_model_exclude_none=route.response_model_exclude_none,
+            include_in_schema=route.include_in_schema,
+            name=route.name,
+            openapi_extra=route.openapi_extra,
+        )
+    return _router
 
 
 class Configurator:
@@ -102,18 +136,35 @@ class Configurator:
         self.api_description: str = ""
         self.api_summary: str | None = None
 
-        self.router = Router()
+        self._route_prefix: str = ""
+        self._routers: dict[str, Router] = defaultdict(Router)
+        self._security_policies: dict[str, "type[AbstractSecurityPolicy[Any]]"] = {}
+
         self.scanner = venusian.Scanner(fastlife=self)
         self.include("fastlife.views")
         self.include("fastlife.middlewares")
 
+    @property
+    def _current_router(self) -> Router:
+        return self._routers[self._route_prefix]
+
     def build_asgi_app(self) -> FastAPI:
         """
         Build the app after configuration in order to start after beeing configured.
 
         :return: FastAPI application.
         """
-        _app = FastAPI(
+
+        # register our main template renderer at then end, to ensure that
+        # if settings have been manipulated, everythins is taken into account.
+        self.add_renderer(
+            self.registry.settings.jinjax_file_ext,
+            resolve("fastlife.adapters.jinjax.renderer:JinjaxTemplateRenderer")(
+                self.registry.settings
+            ),
+        )
+
+        app = FastAPI(
             title=self.api_title,
             version=self.api_version,
             description=self.api_description,
@@ -125,48 +176,35 @@ class Configurator:
             if self.tags
             else None,
         )
-        _app.router.route_class = Route
-        for _route in self.router.routes:
-            route = cast(Route, _route)
-            _app.router.add_api_route(
-                path=route.path,
-                endpoint=route.endpoint,
-                response_model=route.response_model,
-                status_code=route.status_code,
-                tags=route.tags,
-                dependencies=route.dependencies,
-                summary=route.summary,
-                description=route.description,
-                response_description=route.response_description,
-                deprecated=route.deprecated,
-                methods=route.methods,
-                operation_id=route.operation_id,
-                response_model_include=route.response_model_include,
-                response_model_exclude=route.response_model_exclude,
-                response_model_by_alias=route.response_model_by_alias,
-                response_model_exclude_unset=route.response_model_exclude_unset,
-                response_model_exclude_defaults=route.response_model_exclude_defaults,
-                response_model_exclude_none=route.response_model_exclude_none,
-                include_in_schema=route.include_in_schema,
-                name=route.name,
-                openapi_extra=route.openapi_extra,
-            )
+        app.router.route_class = Route
 
         for middleware_class, options in self.middlewares:
-            _app.add_middleware(middleware_class, **options)  # type: ignore
+            app.add_middleware(middleware_class, **options)  # type: ignore
 
         for status_code_or_exc, exception_handler in self.exception_handlers:
-            _app.add_exception_handler(status_code_or_exc, exception_handler)
+            app.add_exception_handler(status_code_or_exc, exception_handler)
+
+        for prefix, router in self._routers.items():
+            app.include_router(rebuild_router(router), prefix=prefix)
 
         for route_path, directory, name in self.mounts:
-            _app.mount(route_path, StaticFiles(directory=directory), name=name)
-        return _app
+            app.mount(route_path, StaticFiles(directory=directory), name=name)
+        return app
 
-    def include(self, module: str | ModuleType) -> Self:
+    def include(
+        self,
+        module: str | ModuleType,
+        route_prefix: str = "",
+        ignore: venusian_ignored_item | Sequence[venusian_ignored_item] | None = None,
+    ) -> Self:
         """
         Include a module in order to load its configuration.
 
-        It will load and include all the submodule as well.
+        It will scan and load all the submodule until you add an ignore rule.
+
+        The `ignore` argument allows you to ignore certain modules.
+        If it is a scrint, it can be an absolute module name or a relative
+        one, if starts with a dot.
 
         Here is an example.
 
@@ -182,6 +220,8 @@ class Configurator:
         ```
 
         :param module: a module to include.
+        :param route_prefix: prepend all included route with a prefix
+        :param ignore: ignore submodules
         """
         if isinstance(module, str):
             package = None
@@ -190,7 +230,15 @@ class Configurator:
                 package = caller_module.__name__ if caller_module else "__main__"
 
             module = importlib.import_module(module, package)
-        self.scanner.scan(module, categories=[VENUSIAN_CATEGORY])  # type: ignore
+        old, self._route_prefix = self._route_prefix, route_prefix
+        try:
+            self.scanner.scan(  # type: ignore
+                module,
+                categories=[VENUSIAN_CATEGORY],
+                ignore=ignore,
+            )
+        finally:
+            self._route_prefix = old
         return self
 
     def set_locale_negociator(self, locale_negociator: "LocaleNegociator") -> Self:
@@ -247,6 +295,27 @@ class Configurator:
         self.middlewares.append((middleware_class, options))
         return self
 
+    def set_security_policy(
+        self, security_policy: "type[AbstractSecurityPolicy[Any]]"
+    ) -> Self:
+        """
+        Set a security policy for the application.
+
+        ```{important}
+        The security policy is **per route_prefix**.
+        It means that if the application is splitted via multiple
+        route_prefix using the {meth}`Configurator.include`, they
+        all have a distinct security policy. A secutity policy has
+        to be install by all of those include call.
+
+        :param security_policy: The security policy that will applied for the app
+            portion behind the route prefix.
+        ```
+        """
+        self._security_policies[self._route_prefix] = security_policy
+        self._current_router.dependencies.append(Depends(security_policy))
+        return self
+
     def add_api_route(
         self,
         name: str,
@@ -296,9 +365,7 @@ class Configurator:
         :param path: path of the route, use `{curly_brace}` to inject FastAPI Path
             parameters.
         :param endpoint: the function that will reveive the request.
-        :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 methods: restrict route to a list of http methods.
         :param description:OpenAPI description for the route.
         :param summary: OpenAPI summary for the route.
@@ -324,9 +391,9 @@ class Configurator:
         """
         dependencies: list[DependsType] = []
         if permission:
-            dependencies.append(Depends(self.registry.check_permission(permission)))
+            dependencies.append(Depends(check_permission(permission)))
 
-        self.router.add_api_route(
+        self._current_router.add_api_route(
             path,
             endpoint,
             # response_model=response_model,
@@ -379,15 +446,13 @@ class Configurator:
         :param path: path of the route, use `{curly_brace}` to inject FastAPI Path
             parameters.
         :param endpoint: the function that will reveive the request.
-        :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 methods: restrict route to a list of http methods.
         :return: the configurator.
         """
         dependencies: list[DependsType] = []
         if permission:
-            dependencies.append(Depends(self.registry.check_permission(permission)))
+            dependencies.append(Depends(check_permission(permission)))
 
         if template:
 
@@ -404,7 +469,7 @@ class Configurator:
 
             endpoint = render
 
-        self.router.add_api_route(
+        self._current_router.add_api_route(
             path,
             endpoint,
             status_code=status_code,
@@ -444,6 +509,11 @@ class Configurator:
         """
 
         def exception_handler(request: BaseRequest, exc: Exception) -> Any:
+            # FastAPI exception handler does not provide our request object
+            # it seems like it is rebuild from the asgi scope. Even the router
+            # 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)
             if isinstance(resp, Response):
@@ -479,6 +549,17 @@ class Configurator:
         self.registry.renderers[f".{file_ext.lstrip('.')}"] = renderer  # type: ignore
         return self
 
+    def add_template_search_path(self, path: str) -> Self:
+        """
+        Add a template search path directly from the code.
+
+        :param path: template path.
+        """
+        self.registry.settings.template_search_path = (
+            f"{self.registry.settings.template_search_path},{path}"
+        )
+        return self
+
 
 def configure(
     wrapped: Callable[[Configurator], None],

fastlife/config/openapiextra.py

@@ -0,0 +1,22 @@
+"""Types for OpenAPI documentation."""
+from pydantic import BaseModel, Field
+
+
+class ExternalDocs(BaseModel):
+    """OpenAPI externalDocs object."""
+
+    description: str
+    """link's description."""
+    url: str
+    """link's URL."""
+
+
+class OpenApiTag(BaseModel):
+    """OpenAPI tag object."""
+
+    name: str
+    """name of the tag."""
+    description: str
+    """explanation of the tag."""
+    external_docs: ExternalDocs | None = Field(alias="externalDocs", default=None)
+    """external link to the doc."""

fastlife/config/registry.py

@@ -5,9 +5,7 @@ from fastapi import Depends
 from fastapi import Request as FastAPIRequest
 
 from fastlife.request.request import Request
-from fastlife.security.policy import CheckPermission
 from fastlife.services.translations import LocalizerFactory
-from fastlife.shared_utils.resolver import resolve
 
 if TYPE_CHECKING:
     from fastlife.services.templates import (  # coverage: ignore
@@ -34,19 +32,13 @@ class AppRegistry:
 
     settings: Settings
     renderers: Mapping[str, "AbstractTemplateRendererFactory"]
-    check_permission: CheckPermission
     locale_negociator: LocaleNegociator
     localizer: LocalizerFactory
 
     def __init__(self, settings: Settings) -> None:
         self.settings = settings
-        self.check_permission = resolve(settings.check_permission)
         self.locale_negociator = _default_negociator(self.settings)
-        self.renderers = {
-            f".{settings.jinjax_file_ext}": resolve(
-                "fastlife.adapters.jinjax.renderer:JinjaxTemplateRenderer"
-            )(settings),
-        }
+        self.renderers = {}
         self.localizer = LocalizerFactory()
 
     def get_renderer(self, template: str) -> "AbstractTemplateRendererFactory":

fastlife/config/resources.py

@@ -13,11 +13,12 @@ from typing import Any, Callable
 import venusian
 from fastapi.types import IncEx
 
+from fastlife.config.openapiextra import ExternalDocs
+
 from .configurator import (
     VENUSIAN_CATEGORY,
     ConfigurationError,
     Configurator,
-    ExternalDocs,
     OpenApiTag,
 )
 
@@ -143,6 +144,7 @@ def resource(
 
 
 def resource_view(
+    *,
     permission: str | None = None,
     status_code: int | None = None,
     summary: str | None = None,

fastlife/config/settings.py

@@ -106,9 +106,6 @@ class Settings(BaseSettings):
     domain_name: str = Field(default="", title="domain name where the app is served")
     """Domain name whre the app is served."""
 
-    check_permission: str = Field(default="fastlife.security.policy:check_permission")
-    """Handler for checking permission set on any views using the configurator."""
-
     decode_reverse_proxy_headers: bool = Field(default=True)
     """Ensure that the request object has information based on http proxy headers."""
 

fastlife/request/request.py

@@ -1,11 +1,15 @@
 """HTTP Request representation in a python object."""
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from fastapi import Request as FastAPIRequest
 
 if TYPE_CHECKING:
     from fastlife.config.registry import AppRegistry  # coverage: ignore
+    from fastlife.security.policy import (  # coverage: ignore
+        AbstractSecurityPolicy,
+        HasPermission,
+    )
 
 
 class Request(FastAPIRequest):
@@ -16,7 +20,30 @@ class Request(FastAPIRequest):
     locale_name: str
     """Request locale used for the i18n of the response."""
 
+    security_policy: "AbstractSecurityPolicy[Any] | None"
+    """Request locale used for the i18n of the response."""
+
     def __init__(self, registry: "AppRegistry", request: FastAPIRequest) -> None:
         super().__init__(request.scope, request.receive)
         self.registry = registry
         self.locale_name = registry.locale_negociator(self)
+        self.security_policy = None  # build it from the ? registry
+
+    async def has_permission(
+        self, permission: str
+    ) -> "HasPermission | type[HasPermission]":
+        """
+        A helper to check that a user has the given permission.
+
+        Not that this method does not raised, it return a boolean like object.
+        It allows batch permission checks.
+        You might need to check multiple permissions in different contexts or
+        for different resources before raising an http error.
+        """
+        if self.security_policy is None:
+            raise RuntimeError(
+                f"Request {self.url.path} require a security policy, "
+                "explicit fastlife.security.policy.InsecurePolicy is required."
+            )
+
+        return await self.security_policy.has_permission(permission)

fastlife/security/policy.py

@@ -1,26 +1,171 @@
 """Security policy."""
-from typing import Any, Callable, Coroutine
+
+import abc
+import logging
+from typing import Any, Callable, Coroutine, Literal, TypeVar
+from uuid import UUID
+
+from fastapi import HTTPException
+from starlette.status import HTTP_401_UNAUTHORIZED, HTTP_403_FORBIDDEN
+from typing_extensions import Generic
+
+from fastlife import Request
 
 CheckPermissionHook = Callable[..., Coroutine[Any, Any, None]] | Callable[..., None]
 CheckPermission = Callable[[str], CheckPermissionHook]
 
+TUser = TypeVar("TUser")
+
+log = logging.getLogger(__name__)
+
+
+class Unauthorized(HTTPException):
+    """An exception raised to stop a request exectution and return an HTTP Error."""
+
+    def __init__(
+        self,
+        status_code: int = HTTP_401_UNAUTHORIZED,
+        detail: str = "Unauthorized",
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        super().__init__(status_code, detail, headers)
+
+
+class Forbidden(HTTPException):
+    """An exception raised to stop a request exectution and return an HTTP Error."""
+
+    def __init__(
+        self,
+        status_code: int = HTTP_403_FORBIDDEN,
+        detail: str = "Forbidden",
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        super().__init__(status_code, detail, headers)
+
+
+class BoolMeta(type):
+    def __bool__(cls) -> bool:
+        return cls.kind == "allowed"  # type: ignore
+
+    def __repr__(cls) -> str:
+        return cls.reason  # type: ignore
+
+
+class HasPermission(int, metaclass=BoolMeta):
+    kind: Literal["allowed", "unauthenticated", "denied"]
+    reason: str
+
+    def __new__(cls, reason: str) -> "HasPermission":
+        instance = super().__new__(cls)
+        instance.reason = reason
+        return instance
+
+    def __repr__(self) -> str:
+        return self.reason
+
+    def __bool__(self) -> bool:
+        return self.kind == "allowed"
+
+
+class Allowed(HasPermission):
+    """Represent a permission check result that is allowed."""
+
+    kind = "allowed"
+    reason = "Allowed"
+
 
-def check_permission(permission_name: str) -> CheckPermissionHook:
+class Unauthenticated(HasPermission):
+    """
+    Represent a permission check result that is not allowed due to
+    missing authentication mechanism.
     """
-    A closure that check that a user as the given permission_name.
 
-    This method has to be overriden using the setting
-    :attr:`fastlife.config.settings.Settings.check_permission` to implement it.
+    kind = "unauthenticated"
+    reason = "Authentication required"
 
-    When the check permission is properly set in the settings., the hook is called
-    for every route added with a permission keyword.
-    {meth}`fastlife.config.configurator.Configurator.add_route`
 
-    :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.
+class Denied(HasPermission):
+    """
+    Represent a permission check result that is not allowed due to lack of permission.
     """
 
-    def depencency_injection() -> None:
-        ...
+    kind = "denied"
+    reason = "Access denied to this resource"
+
+
+class AbstractSecurityPolicy(abc.ABC, Generic[TUser]):
+    """Security policy base classe."""
+
+    Forbidden = Forbidden
+    """The exception raised if the user identified is not granted."""
+    Unauthorized = Unauthorized
+    """The exception raised if no user has been identified."""
+
+    def __init__(self, request: Request):
+        """
+        Build the security policy.
+
+        When implementing a security policy, multiple parameters can be added
+        to the constructor as FastAPI dependencies, using the `Depends` FastAPI
+        annotation.
+        The security policy is installed has a depenency of the router that hold
+        a route prefix of the application.
+        """
+        self.request = request
+        self.request.security_policy = self  # we do backref to implement has_permission
+
+    @abc.abstractmethod
+    async def identity(self) -> TUser | None:
+        """
+        Return app-specific user object or raise an HTTPException.
+        """
+
+    @abc.abstractmethod
+    async def authenticated_userid(self) -> str | UUID | None:
+        """
+        Return app-specific user object or raise an HTTPException.
+        """
+
+    @abc.abstractmethod
+    async def has_permission(
+        self, permission: str
+    ) -> HasPermission | type[HasPermission]:
+        """Allow access to everything if signed in."""
+
+    @abc.abstractmethod
+    async def remember(self, user: TUser) -> None:
+        """Save the user identity in the request session."""
+
+    @abc.abstractmethod
+    async def forget(self) -> None:
+        """Destroy the request session."""
+
+
+class InsecurePolicy(AbstractSecurityPolicy[None]):
+    """
+    An implementation of the security policy made for explicit unsecured access.
+
+    Setting a permission on a view require a security policy, if not set, accessing
+    to a view will raise a RuntimeError. To bypass this error for testing purpose
+    or your own reason, the InsecurePolicy has to be set to the configurator.
+    """
+
+    async def identity(self) -> None:
+        """Nobodies is identified."""
+        return None
+
+    async def authenticated_userid(self) -> str | UUID:
+        """An uuid mades of 0."""
+        return UUID(int=0)
+
+    async def has_permission(
+        self, permission: str
+    ) -> HasPermission | type[HasPermission]:
+        """Access is allways granted."""
+        return Allowed
+
+    async def remember(self, user: None) -> None:
+        """Do nothing."""
 
-    return depencency_injection
+    async def forget(self) -> None:
+        """Do nothing."""

fastlife/services/policy.py

@@ -0,0 +1,39 @@
+"""Security policy."""
+
+from typing import Any, Callable, Coroutine
+
+CheckPermissionHook = Callable[..., Coroutine[Any, Any, None]] | Callable[..., None]
+CheckPermission = Callable[[str], CheckPermissionHook]
+
+
+def check_permission(permission_name: str) -> CheckPermissionHook:
+    """
+    A closure that check that a user as the given permission_name.
+
+    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`
+
+    :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.
+    """
+    # the check_permission is called by the configurator
+    # and the request is exposed in the public module creating a circular dependency.
+    from fastlife import Request  # a type must be resolved to inject a dependency.
+
+    async def depencency_injection(request: Request) -> None:
+        if request.security_policy is None:
+            raise RuntimeError(
+                f"Request {request.url.path} require a security policy, "
+                "explicit fastlife.security.policy.InsecurePolicy is required"
+            )
+        allowed = await request.security_policy.has_permission(permission_name)
+        match allowed.kind:
+            case "allowed":
+                return
+            case "denied":
+                raise request.security_policy.Forbidden(detail=allowed.reason)
+            case "unauthenticated":
+                raise request.security_policy.Unauthorized(detail=allowed.reason)
+
+    return depencency_injection

fastlife/services/translations.py

@@ -114,10 +114,10 @@ class LocalizerFactory:
         for locale_name, domain, file_ in find_mo_files(root_path):
             with file_.open("rb") as f:
                 t = Translations(f, domain)
-                if locale_name in self._translations:
-                    self._translations[locale_name].merge(t)
-                else:
-                    self._translations[locale_name] = t
+                if locale_name not in self._translations:
+                    self._translations[locale_name] = Translations()
+                self._translations[locale_name].add(t)
+                self._translations[locale_name].merge(t)
 
     def __call__(self, request: "Request") -> Localizer:
         """Create the translation context for the given request."""

{fastlifeweb-0.13.0.dist-info → fastlifeweb-0.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastlifeweb
-Version: 0.13.0
+Version: 0.15.0
 Summary: High-level web framework
 Home-page: https://github.com/mardiros/fastlife
 License: BSD-derived

{fastlifeweb-0.13.0.dist-info → fastlifeweb-0.15.0.dist-info}/RECORD

@@ -1666,11 +1666,12 @@ fastlife/components/pydantic_form/Textarea.jinja,sha256=NzfCi5agRUSVcb5RXw0QamM8
 fastlife/components/pydantic_form/Union.jinja,sha256=czTska54z9KCZKu-FaycLmOvtH6y6CGUFQ8DHnkjrJk,1461
 fastlife/components/pydantic_form/Widget.jinja,sha256=EXskDqt22D5grpGVwlZA3ndve2Wr_6yQH4qVE9c31Og,397
 fastlife/config/__init__.py,sha256=O_Mw2XOxo55SArHdGKRhlTrroRN8ymwfzYKlHG0eV_s,418
-fastlife/config/configurator.py,sha256=gfHCnPzxXJGnZ6rTbBy2lkGSGRZOEyGjJnVWbMCDrdo,18048
+fastlife/config/configurator.py,sha256=e0PeDn6S0swsXAJ79-E6zpnonrYwoFHsfEIEzVaCzls,21222
 fastlife/config/exceptions.py,sha256=2MS2MFgb3mDbtdHEwnC-QYubob3Rl0v8O8y615LY0ds,1180
-fastlife/config/registry.py,sha256=pqOnbUPP7Boc42nndvweturuA5X61yhC2bbe8G08T4o,2120
-fastlife/config/resources.py,sha256=Db183g_CC0Voa6IblaNSzcv7XBH1S3s2nTAFNXtz9Cg,8732
-fastlife/config/settings.py,sha256=ZMjfx_XQhu6mPE5q3eI9dG5disnbGUcALUqNYDCknhk,4199
+fastlife/config/openapiextra.py,sha256=_9rBYeTqB7nVuzvUHMwZU387bTfYFHYLlP05NP0vEDs,513
+fastlife/config/registry.py,sha256=Zm3i9ZfQZOP3vNKNKQ8nar7XevI91bqy2tUXX492Fuk,1749
+fastlife/config/resources.py,sha256=pM0j5VKVbVak4Z5mFRHBjAjUqORP4TAtCnZM3res5o8,8776
+fastlife/config/settings.py,sha256=FepHFZVHPLy3yA3dQux79GiH65MkipqWyT-zgXUBOKE,4028
 fastlife/config/views.py,sha256=Dxi6lO4gFs6GriAW7Rh5GDvebwbrpS2HzYhf30pXJiE,2058
 fastlife/middlewares/__init__.py,sha256=C3DUOzR5EhlAv5Zq7h-Abyvkd7bUsJohTRSB2wpRYQE,220
 fastlife/middlewares/base.py,sha256=9OYqByRuVoIrLt353NOedPQTLdr7LSmxhb2BZcp20qk,638
@@ -1684,16 +1685,17 @@ fastlife/request/__init__.py,sha256=C5lZAsUZJDw0TfTegRyN5BEhzgfiqvfc8YXu2vp0siU,
 fastlife/request/form.py,sha256=FucGua79LCKqNBP6Ycle7-5JU6EMI6SrHCgoJBcvGY4,3532
 fastlife/request/form_data.py,sha256=yoP-AYF-dSClpCQuZNRTY-c1OnDga5MoTjBKIzgpTs8,4459
 fastlife/request/localizer.py,sha256=9MXAcsod-Po5qeg4lttD3dyumiI0y5vGHCwSSmt9or8,349
-fastlife/request/request.py,sha256=ACteAZUEaQHhE7l7LDEzY1wDhTegCKr-rsQmzTwtsGY,695
+fastlife/request/request.py,sha256=NiRtEV_iw8BuESQPf7gqXxiHsQwLiyOu1yzQy7Ck9eM,1779
 fastlife/routing/__init__.py,sha256=8EMnQE5n8oA4J9_c3nxzwKDVt3tefZ6fGH0d2owE8mo,195
 fastlife/routing/route.py,sha256=8RMnAqun8GTfWp6PFIWmWu-q-K89M3SiVSi2A-DYqyM,1405
 fastlife/routing/router.py,sha256=bLZ4k2aDs4L423znwGnw-X2LnM36O8fjhDWc8q1WewI,481
 fastlife/security/__init__.py,sha256=QYDcJ3oXQzqXQxoDD_6biGAtercFrtePttoifiL1j34,25
 fastlife/security/csrf.py,sha256=PvC9Fqdb6c0IzzsnaMx2quQdjjKrb-nOPoAHfcwoAe8,2141
-fastlife/security/policy.py,sha256=MYNPQlvnTBe1XsYNJoIwiGW2DFb8vciU3XyUi9ZlLt0,945
+fastlife/security/policy.py,sha256=3aENmA_plxHbnUKzsIWtCAboT3oyVew0dcJKDrrILqE,4880
 fastlife/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastlife/services/policy.py,sha256=ZK4K3fVGT1fUeBdo5sSWnEcJg49CZuaI3z2gyg3KguQ,1653
 fastlife/services/templates.py,sha256=7gPJxGWD-XqputbZpy_Icsz3WHKJaWg2JgkVOeKrjfA,3840
-fastlife/services/translations.py,sha256=R0KXVrm4leUu6p1zJp0QvLUwrQNW5mO88cQ5CZ2mlCE,4317
+fastlife/services/translations.py,sha256=Bo5CIjdbQ3g_ihbv4Bz60hzd8VOtqEEPOyhJEbGcvP4,4363
 fastlife/shared_utils/__init__.py,sha256=i66ytuf-Ezo7jSiNQHIsBMVIcB-tDX0tg28-pUOlhzE,26
 fastlife/shared_utils/infer.py,sha256=CJjsL_F5OQRG7-0_89MQiZhyd7IcMGyirlQhjtcaIT4,728
 fastlife/shared_utils/resolver.py,sha256=BRU88Ej4oA1iDIyG4Z6T7Q9WFvPHiMm6zuSh623312A,1725
@@ -1704,7 +1706,7 @@ fastlife/testing/__init__.py,sha256=vuqwoNUd3BuIp3fm7nkvmYkIGjIimf5zUGhDkeWrg2s,
 fastlife/testing/testclient.py,sha256=BC7lLQ_jc59UmknAKzgRtW9a3cpX_V_QLp9Mg2ScLA8,20546
 fastlife/views/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastlife/views/pydantic_form.py,sha256=fvjk_5-JAugpBPxwD5GkxxsQiz9eAxzWeCSU9kiyc6s,1438
-fastlifeweb-0.13.0.dist-info/LICENSE,sha256=F75xSseSKMwqzFj8rswYU6NWS3VoWOc_gY3fJYf9_LI,1504
-fastlifeweb-0.13.0.dist-info/METADATA,sha256=yhn48LhvuV19WZhJI4HykIgEjmd85Mu3n3Tv_GqkpQo,3278
-fastlifeweb-0.13.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-fastlifeweb-0.13.0.dist-info/RECORD,,
+fastlifeweb-0.15.0.dist-info/LICENSE,sha256=F75xSseSKMwqzFj8rswYU6NWS3VoWOc_gY3fJYf9_LI,1504
+fastlifeweb-0.15.0.dist-info/METADATA,sha256=_1D_y-_GWIJCaw4ZbZs9LT7O4nfhwdQ4p9Kzlo0BAY4,3278
+fastlifeweb-0.15.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+fastlifeweb-0.15.0.dist-info/RECORD,,