fastlifeweb 0.10.0__tar.gz → 0.11.1__tar.gz

{fastlifeweb-0.10.0 → fastlifeweb-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastlifeweb
-Version: 0.10.0
+Version: 0.11.1
 Summary: High-level web framework
 Home-page: https://github.com/mardiros/fastlife
 License: BSD-derived
@@ -18,35 +18,30 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: beautifulsoup4[testing] (>=4.12.2,<5.0.0)
-Requires-Dist: behave (>=1.2.6,<2.0.0)
-Requires-Dist: fastapi (>=0.112.0,<0.113.0)
+Requires-Dist: fastapi[standard] (>=0.115.0,<0.116.0)
 Requires-Dist: itsdangerous (>=2.1.2,<3.0.0)
 Requires-Dist: jinjax (>=0.44,<0.45)
 Requires-Dist: markupsafe (>=2.1.3,<3.0.0)
 Requires-Dist: multidict (>=6.0.5,<7.0.0)
 Requires-Dist: pydantic (>=2.5.3,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.0.3,<3.0.0)
-Requires-Dist: python-multipart (>=0.0.6,<0.0.7)
+Requires-Dist: python-multipart (>=0.0.9,<0.0.10)
 Requires-Dist: venusian (>=3.0.0,<4.0.0)
 Project-URL: Repository, https://github.com/mardiros/fastlife
 Description-Content-Type: text/markdown
 
 # Fastlife
 
-[![CI](https://github.com/mardiros/fastlife/actions/workflows/main.yml/badge.svg)](https://github.com/mardiros/fastlife/actions/workflows/main.yml)
-
-[![codecov](https://codecov.io/gh/mardiros/fastlife/graph/badge.svg?token=DTpi73d7mf)](https://codecov.io/gh/mardiros/fastlife)
-
+[![Documentation](https://github.com/mardiros/fastlife/actions/workflows/gh-pages.yml/badge.svg)](https://mardiros.github.io/fastlife/)
+[![Continuous Integration](https://github.com/mardiros/fastlife/actions/workflows/main.yml/badge.svg)](https://github.com/mardiros/fastlife/actions/workflows/main.yml)
+[![Coverage Report](https://codecov.io/gh/mardiros/fastlife/graph/badge.svg?token=DTpi73d7mf)](https://codecov.io/gh/mardiros/fastlife)
 
 A high-level Python web framework based on FastAPI, JinjaX, Pydandic and htmx.
 
 The intention is to prototype web application fast. It generate forms directly from
 Pydantic models.
 
-
-
 Under heavy development.
 
-
 The package is available on pypi with the name fastlifeweb.
 

fastlifeweb-0.11.1/README.md

@@ -0,0 +1,14 @@
+# Fastlife
+
+[![Documentation](https://github.com/mardiros/fastlife/actions/workflows/gh-pages.yml/badge.svg)](https://mardiros.github.io/fastlife/)
+[![Continuous Integration](https://github.com/mardiros/fastlife/actions/workflows/main.yml/badge.svg)](https://github.com/mardiros/fastlife/actions/workflows/main.yml)
+[![Coverage Report](https://codecov.io/gh/mardiros/fastlife/graph/badge.svg?token=DTpi73d7mf)](https://codecov.io/gh/mardiros/fastlife)
+
+A high-level Python web framework based on FastAPI, JinjaX, Pydandic and htmx.
+
+The intention is to prototype web application fast. It generate forms directly from
+Pydantic models.
+
+Under heavy development.
+
+The package is available on pypi with the name fastlifeweb.

{fastlifeweb-0.10.0 → fastlifeweb-0.11.1}/pyproject.toml

@@ -15,24 +15,27 @@ classifiers = [
   "Topic :: Software Development :: Libraries :: Python Modules",
   "Topic :: Internet :: WWW/HTTP",
 ]
-version = "0.10.0"
+version = "0.11.1"
 
 [tool.poetry.dependencies]
 python = "^3.11"
 beautifulsoup4 = {version = "^4.12.2", extras = ["testing"]}
-behave = "^1.2.6"
-fastapi = "^0.112.0"
+fastapi = { version = "^0.115.0", extras = ["standard"]}
 itsdangerous = "^2.1.2"
 jinjax = "^0.44"
 markupsafe = "^2.1.3"
 multidict = "^6.0.5"
 pydantic = "^2.5.3"
 pydantic-settings = "^2.0.3"
-python-multipart = "^0.0.6"
+python-multipart = "^0.0.9"
 venusian = "^3.0.0"
 
+[tool.poetry.group.dev]
+optional = true
+
 [tool.poetry.group.dev.dependencies]
 beautifulsoup4 = "^4.12.2"
+behave = "^1.2.6"
 black = "^23.3.0"
 flake8 = "^6.1.0"
 heroicons = "^2.7.0"
@@ -48,6 +51,16 @@ hypercorn = "^0.14.4"
 pytest-playwright = "^0.4.3"
 pytailwindcss = "^0.2.0"
 
+[tool.poetry.group.doc]
+optional = true
+
+[tool.poetry.group.doc.dependencies]
+furo = "^2024.5.6"
+myst-parser = "^4.0.0"
+sphinx = "^7.0.1"
+sphinx-autodoc-typehints = "^1.12.0"
+sphinx-autodoc2 = "^0.5.0"
+tomlkit = "^0.12.5"
 
 [tool.pyright]
 include = ["src"]

{fastlifeweb-0.10.0 → fastlifeweb-0.11.1}/src/fastlife/__init__.py

@@ -1,5 +1,4 @@
-from .configurator import Configurator, configure
-from .configurator.registry import Registry
+from .config import Configurator, Registry, Settings, configure
 
 # from .request.form_data import model
 from .templating import Template, template
@@ -11,6 +10,7 @@ __all__ = [
     "template",
     "Template",
     "Registry",
+    "Settings",
     # Model
     # "model",
 ]

fastlifeweb-0.11.1/src/fastlife/config/__init__.py

@@ -0,0 +1,13 @@
+"""Configure fastlife app for dependency injection."""
+
+from .configurator import Configurator, configure
+from .registry import AppRegistry, Registry
+from .settings import Settings
+
+__all__ = [
+    "Configurator",
+    "configure",
+    "Registry",
+    "AppRegistry",
+    "Settings",
+]

{fastlifeweb-0.10.0/src/fastlife/configurator → fastlifeweb-0.11.1/src/fastlife/config}/configurator.py

@@ -1,6 +1,14 @@
 """
-The configurator is here to register routes in a fastapi app,
-with dependency injection.
+The configurator registers routes in a FastAPI application while
+adding support for dependency injection during the configuration phase.
+
+FastAPI does not provide any built-in support for dependency injection
+during the configuration phase.
+Instead, it only resolves dependencies at request time, ensuring they
+are dynamically handled per request.
+
+The configurator is designed to handle the setup during the configuration
+phase.
 """
 
 import importlib
@@ -9,28 +17,20 @@ import logging
 from enum import Enum
 from pathlib import Path
 from types import ModuleType
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Coroutine,
-    List,
-    Optional,
-    Self,
-    Type,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, Callable, List, Optional, Self, Type, Union
 
 import venusian
-from fastapi import Depends, FastAPI, Request, Response
+from fastapi import Depends, FastAPI
+from fastapi import Request as BaseRequest
 from fastapi.params import Depends as DependsType
 from fastapi.staticfiles import StaticFiles
 
-from fastlife.configurator.base import AbstractMiddleware
-from fastlife.configurator.route_handler import FastlifeRoute
+from fastlife.middlewares.base import AbstractMiddleware
+from fastlife.request.request import Request
+from fastlife.routing.route import Route
 from fastlife.security.csrf import check_csrf
+from fastlife.shared_utils.resolver import resolve
 
-from .route_handler import FastlifeRequest
 from .settings import Settings
 
 if TYPE_CHECKING:
@@ -45,49 +45,53 @@ class Configurator:
     Configure and build an application.
 
     Initialize the app from the settings.
-
-    :param settings: Application settings.
     """
 
     registry: "AppRegistry"
 
     def __init__(self, settings: Settings) -> None:
-        from .registry import initialize_registry  # XXX circular import
-
-        self.registry = initialize_registry(settings)
+        """
+        :param settings: Application settings.
+        """
+        registry_cls = resolve(settings.registry_class)
+        self.registry = registry_cls(settings)
         self._app = FastAPI(
-            dependencies=[Depends(check_csrf(self.registry))],
+            dependencies=[Depends(check_csrf())],
             docs_url=None,
             redoc_url=None,
         )
-        FastlifeRoute.registry = self.registry
-        self._app.router.route_class = FastlifeRoute
+        Route._registry = self.registry  # type: ignore
+        self._app.router.route_class = Route
         self.scanner = venusian.Scanner(fastlife=self)
         self.include("fastlife.views")
         self.include("fastlife.middlewares")
 
-    def get_app(self) -> FastAPI:
+    def get_asgi_app(self) -> FastAPI:
         """
         Get the app after configuration in order to start after beeing configured.
 
-        :return: FastAPI application
+        :return: FastAPI application.
         """
         return self._app
 
     def include(self, module: str | ModuleType) -> "Configurator":
         """
-        Include a module in order to load its views.
+        Include a module in order to load its configuration.
 
-        Here is an example.
+        It will load and include all the submodule as well.
 
-        ::
+        Here is an example.
 
-            from fastlife import Configurator, configure
+        ```python
+        from fastlife import Configurator, configure
 
-            @configure
-            def includeme(config: Configurator) -> None:
-                config.include(".views")
+        def home() -> dict[str, str]:
+            return {"hello": "world"}
 
+        @configure
+        def includeme(config: Configurator) -> None:
+            config.add_route("home", "/", home)
+        ```
 
         :param module: a module to include.
         """
@@ -114,7 +118,7 @@ class Configurator:
         self,
         name: str,
         path: str,
-        endpoint: Callable[..., Coroutine[Any, Any, Response]],
+        endpoint: Callable[..., Any],
         *,
         permission: str | None = None,
         status_code: int | None = None,
@@ -142,7 +146,26 @@ class Configurator:
         #     generate_unique_id
         # ),
     ) -> "Configurator":
-        """Add a route to the app."""
+        """
+        Add a route to the app.
+
+        Fastlife does not use a decorator to attach routes, instead the decorator
+        :func:`fastlife.config.configurator.configure` has to be used to
+        inject routes inside a method and call the add_route method.
+
+        :param name: name of the route, used to build route from the helper
+            :meth:`fastlife.request.request.Request.url_for` in order to create links.
+        :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 methods: restrict route to a list of http methods.
+        :param response_description: description for the response.
+        :param deprecated: mark the route as deprecated.
+        :return: the configurator.
+        """
         dependencies: List[DependsType] = []
         if permission:
             dependencies.append(Depends(self.registry.check_permission(permission)))
@@ -181,7 +204,7 @@ class Configurator:
         """
         Mount a directory to an http endpoint.
 
-        :param route_path: the root path for the statics
+        :param route_path: the root path for the statics.
         :param directory: the directory on the filesystem where the statics files are.
         :param name: a name for the route in the starlette app.
         :return: the configurator
@@ -195,8 +218,8 @@ class Configurator:
     ) -> "Configurator":
         """Add an exception handler the application."""
 
-        def exception_handler(request: Request, exc: Exception) -> Any:
-            req = FastlifeRequest(self.registry, request)
+        def exception_handler(request: BaseRequest, exc: Exception) -> Any:
+            req = Request(self.registry, request)
             return handler(req, exc)
 
         self._app.add_exception_handler(status_code_or_exc, exception_handler)

{fastlifeweb-0.10.0/src/fastlife/configurator → fastlifeweb-0.11.1/src/fastlife/config}/registry.py

@@ -2,7 +2,7 @@ from typing import TYPE_CHECKING, Annotated
 
 from fastapi import Depends
 
-from fastlife.configurator.route_handler import FastlifeRequest
+from fastlife.request.request import Request
 from fastlife.security.policy import CheckPermission
 from fastlife.shared_utils.resolver import resolve
 
@@ -33,15 +33,7 @@ class AppRegistry:
         self.check_permission = resolve(settings.check_permission)
 
 
-def initialize_registry(settings: Settings) -> AppRegistry:
-    # global DEFAULT_REGISTRY
-    # if DEFAULT_REGISTRY is not None:  # type: ignore
-    #     raise ValueError("Registry is already set")
-    AppRegistryCls = resolve(settings.registry_class)
-    return AppRegistryCls(settings)  # type: ignore
-
-
-def get_registry(request: FastlifeRequest) -> AppRegistry:
+def get_registry(request: Request) -> AppRegistry:
     return request.registry
 
 

{fastlifeweb-0.10.0/src/fastlife/configurator → fastlifeweb-0.11.1/src/fastlife/config}/settings.py

@@ -15,7 +15,9 @@ class Settings(BaseSettings):
     """
 
     model_config = SettingsConfigDict(env_prefix="fastlife_")
-    """Set the prefix fastlife_ for configuration using operating system environment."""
+    """
+    Set the prefix ``fastlife_`` for configuration using operating system environment.
+    """
 
     fastlife_route_prefix: str = Field(default="/_fl")
     """Route prefix used for fastlife internal views."""
@@ -27,7 +29,7 @@ class Settings(BaseSettings):
     a python module name. for instance `fastlife:templates` is the direcotry templates
     found in the fastlife package.
     """
-    registry_class: str = Field(default="fastlife.configurator.registry:AppRegistry")
+    registry_class: str = Field(default="fastlife.config.registry:AppRegistry")
     """Implementation class for the application regitry."""
     template_renderer_class: str = Field(
         default="fastlife.templating.renderer:JinjaxTemplateRenderer"
@@ -40,7 +42,9 @@ class Settings(BaseSettings):
     Pydantic form default model prefix for serialized field in www-urlencoded-form.
     """
     csrf_token_name: str = Field(default="csrf_token")
-    """Name of the html input field for csrf token."""
+    """
+    Name of the html input field and for the http cookie for csrf token.
+    """
 
     jinjax_use_cache: bool = Field(default=True)
     """

fastlifeweb-0.11.1/src/fastlife/middlewares/__init__.py

@@ -0,0 +1,7 @@
+"""
+Fastlife HTTP middlewares are Starlette HTTP Middleware.
+
+HTTP middleware is a function that processes requests before they reach
+the view function or modifies responses after the view has processed
+the request.
+"""

fastlifeweb-0.11.1/src/fastlife/middlewares/base.py

@@ -0,0 +1,24 @@
+"""Build you own middleware."""
+
+import abc
+
+from starlette.types import Receive, Scope, Send
+
+
+class AbstractMiddleware(abc.ABC):
+    """
+    Abstract Base Class that represent a fastlife middleware.
+
+    Starlette provide a middleware stack but does not have an abstract base class.
+    This is the only reason this class exists.
+
+    Fastlife middleware are starlette middlewares.
+    """
+
+    @abc.abstractmethod
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        """
+        Called every time an http request is reveived.
+
+        This method before the request object even exists.
+        """

fastlifeweb-0.11.1/src/fastlife/middlewares/reverse_proxy/__init__.py

@@ -0,0 +1,26 @@
+"""
+A middleware that update the request scope for https behind a proxy.
+
+The attempt of this middleware is to fix Starlette behavior that use client and scheme
+header based on the header ``x-forwarded-*`` headers and the ``x-real-ip``.
+
+the ``x-forwarded-for`` header is not parsed to find the appropriate value,
+the ``x-real-ip`` is used.
+notethat the ``x-forwarded-port`` header is not used.
+
+Note that uvicorn or hypercorn offer the same kind middleware.
+
+Norw, every website is in https, so, this middleware is active by default.
+"""
+from fastlife import Configurator, configure
+
+from .x_forwarded import XForwardedStar
+
+__all__ = ["XForwardedStar"]
+
+
+@configure
+def includeme(config: Configurator) -> None:
+    settings = config.registry.settings
+    if settings.decode_reverse_proxy_headers:
+        config.add_middleware(XForwardedStar)

{fastlifeweb-0.10.0 → fastlifeweb-0.11.1}/src/fastlife/middlewares/reverse_proxy/x_forwarded.py

@@ -1,22 +1,9 @@
-"""
-A middleware that update the request scope for https behind a proxy.
-
-The attempt of this middleware is to fix Starlette behavior that use client and scheme
-header based on the header x-forwarded-* headers and the x-real-ip.
-
-the x-forwarded-for header is not parsed to find the appropriate value,
-the x-real-ip is used.
-notethat the x-forwarded-port header is not used.
-
-Note that uvicorn or hypercorn offer the same kind middleware.
-"""
-
 import logging
 from typing import Optional, Sequence, Tuple
 
 from starlette.types import ASGIApp, Receive, Scope, Send
 
-from fastlife.configurator.base import AbstractMiddleware
+from fastlife.middlewares.base import AbstractMiddleware
 
 log = logging.getLogger(__name__)
 

{fastlifeweb-0.10.0 → fastlifeweb-0.11.1}/src/fastlife/middlewares/session/__init__.py

@@ -1,7 +1,23 @@
+"""
+Initialize a session.
+
+
+The session :attr:`fastlife.config.settings.Settings.session_secret_key` must
+be set in order to create a session.
+
+This secret is used to sign session content in order to prevent malicious user
+to write their own session content. Note that the provided session implementation
+does not cipher session content, it just sign. No secret should be placed in the
+session.
+"""
+
 from fastlife import Configurator, configure
 from fastlife.shared_utils.resolver import resolve
 
 from .middleware import SessionMiddleware
+from .serializer import AbsractSessionSerializer, SignedSessionSerializer
+
+__all__ = ["SessionMiddleware", "AbsractSessionSerializer", "SignedSessionSerializer"]
 
 
 @configure

{fastlifeweb-0.10.0 → fastlifeweb-0.11.1}/src/fastlife/middlewares/session/middleware.py

@@ -1,3 +1,5 @@
+"""Deal with http session."""
+
 from datetime import timedelta
 from typing import Literal, Type
 
@@ -5,12 +7,14 @@ from starlette.datastructures import MutableHeaders
 from starlette.requests import HTTPConnection
 from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
-from fastlife.configurator.base import AbstractMiddleware
+from fastlife.middlewares.base import AbstractMiddleware
 
 from .serializer import AbsractSessionSerializer, SignedSessionSerializer
 
 
 class SessionMiddleware(AbstractMiddleware):
+    """Http session based on cookie."""
+
     def __init__(
         self,
         app: ASGIApp,
@@ -36,6 +40,7 @@ class SessionMiddleware(AbstractMiddleware):
             self.security_flags += f"; Domain={cookie_domain}"
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        """Initialize a session based on cookie."""
         if scope["type"] not in ("http", "websocket"):  # pragma: no cover
             await self.app(scope, receive, send)
             return

{fastlifeweb-0.10.0 → fastlifeweb-0.11.1}/src/fastlife/middlewares/session/serializer.py

@@ -1,3 +1,4 @@
+"""Serialize session."""
 import abc
 import json
 from base64 import b64decode, b64encode
@@ -7,31 +8,51 @@ import itsdangerous
 
 
 class AbsractSessionSerializer(abc.ABC):
+    """Session serializer base class"""
+
     @abc.abstractmethod
     def __init__(self, secret_key: str, max_age: int) -> None:
         ...
 
     @abc.abstractmethod
     def serialize(self, data: Mapping[str, Any]) -> bytes:
+        """Serialize the session content to bytes in order to be saved."""
         ...
 
     @abc.abstractmethod
     def deserialize(self, data: bytes) -> Tuple[Mapping[str, Any], bool]:
+        """Derialize the session raw bytes content and return it as a mapping."""
         ...
 
 
 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

fastlifeweb-0.11.1/src/fastlife/request/__init__.py

@@ -0,0 +1,5 @@
+"""HTTP Request."""
+
+from .request import Request
+
+__all__ = ["Request"]

{fastlifeweb-0.10.0 → fastlifeweb-0.11.1}/src/fastlife/request/form.py

@@ -1,9 +1,11 @@
+"""HTTP Form serialization."""
+
 from typing import Any, Callable, Generic, Mapping, Type, TypeVar, get_origin
 
 from fastapi import Depends
 from pydantic import BaseModel, ValidationError
 
-from fastlife.configurator.registry import Registry
+from fastlife.config.registry import Registry
 from fastlife.request.form_data import MappingFormData
 from fastlife.shared_utils.infer import is_union
 

{fastlifeweb-0.10.0 → fastlifeweb-0.11.1}/src/fastlife/request/form_data.py

@@ -1,3 +1,7 @@
+"""
+Set of functions to unserialize www-form-urlencoded format to python simple types.
+"""
+
 from typing import (
     Annotated,
     Any,
@@ -10,7 +14,7 @@ from typing import (
 
 from fastapi import Depends, Request
 
-from fastlife.configurator.registry import Registry
+from fastlife.config.registry import Registry
 
 
 def unflatten_struct(
@@ -20,6 +24,12 @@ def unflatten_struct(
     *,
     csrf_token_name: Optional[str] = None,
 ) -> Mapping[str, Any] | Sequence[Any]:
+    """
+    Take a flatten_input map, with key segmented by `.` and build a nested dict.
+
+    Fastlife use plain old web form to send data via HTTP POST, this function
+    prepare the data before get injected to pydantic for serialization.
+    """
     # we sort to ensure that list index are ordered
     # formkeys = sorted(flatten_input.keys())
     for key in flatten_input:
@@ -71,8 +81,12 @@ def unflatten_struct(
 
 
 async def unflatten_mapping_form_data(
-    request: Request, reg: Registry
+    request: Request, registry: Registry
 ) -> Mapping[str, Any]:
+    """
+    Parse the :meth:`fastlife.request.request.form` and build a nested structure.
+    """
+
     form_data = await request.form()
     form_data_decode_list: MutableMapping[str, Any] = {}
     for key, val in form_data.multi_items():
@@ -90,7 +104,7 @@ async def unflatten_mapping_form_data(
             form_data_decode_list[key] = val
 
     ret = unflatten_struct(
-        form_data_decode_list, {}, csrf_token_name=reg.settings.csrf_token_name
+        form_data_decode_list, {}, csrf_token_name=registry.settings.csrf_token_name
     )  # type: ignore
     return ret  # type: ignore
 
@@ -98,6 +112,9 @@ async def unflatten_mapping_form_data(
 async def unflatten_sequence_form_data(
     request: Request, reg: Registry
 ) -> Sequence[str]:
+    """
+    Parse the :meth:`fastlife.request.request.form` and build a list of structure.
+    """
     form_data = await request.form()
     # Could raise a value error !
     return unflatten_struct(
@@ -106,4 +123,12 @@ async def unflatten_sequence_form_data(
 
 
 MappingFormData = Annotated[Mapping[str, Any], Depends(unflatten_mapping_form_data)]
+"""
+Fast API Dependency to deserialize a :meth:`fastlife.request.request.Request.form`
+to a dict.
+"""
 SequenceFormData = Annotated[Sequence[str], Depends(unflatten_sequence_form_data)]
+"""
+Fast API Dependency to deserialize a :meth:`fastlife.request.request.Request.form`
+to a list.
+"""