fastlifeweb 0.6.1__tar.gz → 0.7.0__tar.gz

{fastlifeweb-0.6.1 → fastlifeweb-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastlifeweb
-Version: 0.6.1
+Version: 0.7.0
 Summary: High-level web framework
 Home-page: https://github.com/mardiros/fastlife
 License: BSD-derived
@@ -19,9 +19,9 @@ 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.110.0,<0.111.0)
+Requires-Dist: fastapi (>=0.112.0,<0.113.0)
 Requires-Dist: itsdangerous (>=2.1.2,<3.0.0)
-Requires-Dist: jinjax (>=0.34,<0.35)
+Requires-Dist: jinjax (>=0.37,<0.38)
 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)

{fastlifeweb-0.6.1 → fastlifeweb-0.7.0}/pyproject.toml

@@ -15,15 +15,15 @@ classifiers = [
   "Topic :: Software Development :: Libraries :: Python Modules",
   "Topic :: Internet :: WWW/HTTP",
 ]
-version = "0.6.1"
+version = "0.7.0"
 
 [tool.poetry.dependencies]
 python = "^3.11"
 beautifulsoup4 = {version = "^4.12.2", extras = ["testing"]}
 behave = "^1.2.6"
-fastapi = "^0.110.0"
+fastapi = "^0.112.0"
 itsdangerous = "^2.1.2"
-jinjax = "^0.34"
+jinjax = "^0.37"
 markupsafe = "^2.1.3"
 multidict = "^6.0.5"
 pydantic = "^2.5.3"

{fastlifeweb-0.6.1 → fastlifeweb-0.7.0}/src/fastlife/configurator/__init__.py

@@ -1,3 +1,4 @@
+"""Configure fastlife app for dependency injection."""
 from .configurator import Configurator, configure
 
 __all__ = ["Configurator", "configure"]

{fastlifeweb-0.6.1 → fastlifeweb-0.7.0}/src/fastlife/configurator/configurator.py

@@ -2,6 +2,7 @@
 The configurator is here to register routes in a fastapi app,
 with dependency injection.
 """
+
 import importlib
 import inspect
 import logging
@@ -26,6 +27,7 @@ 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.security.csrf import check_csrf
 
 from .settings import Settings
@@ -38,6 +40,14 @@ VENUSIAN_CATEGORY = "fastlife"
 
 
 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:
@@ -49,14 +59,37 @@ class Configurator:
             docs_url=None,
             redoc_url=None,
         )
+        FastlifeRoute.registry = self.registry
+        self._app.router.route_class = FastlifeRoute
         self.scanner = venusian.Scanner(fastlife=self)
         self.include("fastlife.views")
         self.include("fastlife.session")
 
     def get_app(self) -> FastAPI:
+        """
+        Get the app after configuration in order to start after beeing configured.
+
+        :return: FastAPI application
+        """
         return self._app
 
     def include(self, module: str | ModuleType) -> "Configurator":
+        """
+        Include a module in order to load its views.
+
+        Here is an example.
+
+        ::
+
+            from fastlife import Configurator, configure
+
+            @configure
+            def includeme(config: Configurator) -> None:
+                config.include(".views")
+
+
+        :param module: a module to include.
+        """
         if isinstance(module, str):
             package = None
             if module.startswith("."):
@@ -70,7 +103,10 @@ class Configurator:
     def add_middleware(
         self, middleware_class: Type[AbstractMiddleware], **options: Any
     ) -> Self:
-        self._app.add_middleware(middleware_class, **options)
+        """
+        Add a starlette middleware to the FastAPI app.
+        """
+        self._app.add_middleware(middleware_class, **options)  # type: ignore
         return self
 
     def add_route(
@@ -105,6 +141,7 @@ class Configurator:
         #     generate_unique_id
         # ),
     ) -> "Configurator":
+        """Add a route to the app."""
         dependencies: List[DependsType] = []
         if permission:
             dependencies.append(Depends(self.registry.check_permission(permission)))
@@ -140,13 +177,22 @@ class Configurator:
     def add_static_route(
         self, route_path: str, directory: Path, name: str = "static"
     ) -> "Configurator":
-        """Mount a directory to an http endpoint."""
+        """
+        Mount a directory to an http endpoint.
+
+        :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
+
+        """
         self._app.mount(route_path, StaticFiles(directory=directory), name=name)
         return self
 
     def add_exception_handler(
         self, status_code_or_exc: int | Type[Exception], handler: Any
     ) -> "Configurator":
+        """Add an exception handler the application."""
         self._app.add_exception_handler(status_code_or_exc, handler)
         return self
 
@@ -154,7 +200,9 @@ class Configurator:
 def configure(
     wrapped: Callable[[Configurator], None]
 ) -> Callable[[Configurator], None]:
-    """Decorator used to attach route in a submodule while using the confirator.scan"""
+    """
+    Decorator used to attach route in a submodule while using the configurator.include.
+    """
 
     def callback(
         scanner: venusian.Scanner, name: str, ob: Callable[[venusian.Scanner], None]

{fastlifeweb-0.6.1 → fastlifeweb-0.7.0}/src/fastlife/configurator/registry.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING, Annotated
 
 from fastapi import Depends
 
+from fastlife.configurator.route_handler import FastlifeRequest
 from fastlife.security.policy import CheckPermission
 from fastlife.shared_utils.resolver import resolve
 
@@ -14,6 +15,11 @@ from .settings import Settings
 
 
 class AppRegistry:
+    """
+    The application registry got fastlife dependency injection.
+    It is initialized by the configurator and accessed by the `fastlife.Registry`.
+    """
+
     settings: Settings
     renderer: "AbstractTemplateRendererFactory"
     check_permission: CheckPermission
@@ -27,22 +33,17 @@ class AppRegistry:
         self.check_permission = resolve(settings.check_permission)
 
 
-DEFAULT_REGISTRY: AppRegistry = None  # type: ignore
-
-
 def initialize_registry(settings: Settings) -> AppRegistry:
-    global DEFAULT_REGISTRY
-    if DEFAULT_REGISTRY is not None:
-        raise ValueError("Registry is already set")
+    # global DEFAULT_REGISTRY
+    # if DEFAULT_REGISTRY is not None:  # type: ignore
+    #     raise ValueError("Registry is already set")
     AppRegistryCls = resolve(settings.registry_class)
-    DEFAULT_REGISTRY = AppRegistryCls(settings)  # type: ignore
-    return DEFAULT_REGISTRY
+    return AppRegistryCls(settings)  # type: ignore
 
 
-def cleanup_registry() -> None:
-    """ "Method to cleanup the registry, used for testing"""
-    global DEFAULT_REGISTRY
-    DEFAULT_REGISTRY = None  # type: ignore
+def get_registry(request: FastlifeRequest) -> AppRegistry:
+    return request.registry
 
 
-Registry = Annotated[AppRegistry, Depends(lambda: DEFAULT_REGISTRY)]
+Registry = Annotated[AppRegistry, Depends(get_registry)]
+"""FastAPI dependency to access to the registry."""

fastlifeweb-0.7.0/src/fastlife/configurator/route_handler.py

@@ -0,0 +1,30 @@
+from typing import TYPE_CHECKING, Any, Callable, Coroutine
+
+from fastapi import Request as BaseRequest
+from fastapi.routing import APIRoute
+from starlette.responses import Response
+from starlette.types import Receive, Scope
+
+if TYPE_CHECKING:
+    from .registry import AppRegistry  # coverage: ignore
+
+
+class FastlifeRequest(BaseRequest):
+    def __init__(self, registry: "AppRegistry", scope: Scope, receive: Receive) -> None:
+        super().__init__(scope, receive)
+        self.registry = registry
+
+
+class FastlifeRoute(APIRoute):
+    registry: "AppRegistry" = None  # type: ignore
+
+    def get_route_handler(  # type: ignore
+        self,
+    ) -> Callable[[FastlifeRequest], Coroutine[Any, Any, Response]]:
+        orig_route_handler = super().get_route_handler()
+
+        async def route_handler(request: BaseRequest) -> FastlifeRequest:
+            req = FastlifeRequest(self.registry, request.scope, request.receive)
+            return await orig_route_handler(req)  # type: ignore
+
+        return route_handler  # type: ignore

fastlifeweb-0.7.0/src/fastlife/configurator/settings.py

@@ -0,0 +1,88 @@
+"""Settings for the fastlife."""
+from datetime import timedelta
+from typing import Literal
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """
+    Settings based on pydantic settings to configure the app.
+
+    It can be overriden in order to inject application own settings.
+    """
+
+    model_config = SettingsConfigDict(env_prefix="fastlife_")
+    """Set the prefix fastlife_ for configuration using operating system environment."""
+
+    fastlife_route_prefix: str = Field(default="/_fl")
+    """Route prefix used for fastlife internal views."""
+    template_search_path: str = Field(default="fastlife:templates")
+    """
+    list of directories where templates could be found by the template engine.
+
+    the list is a comma separated string. The directory resolution is made from
+    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")
+    """Implementation class for the application regitry."""
+    template_renderer_class: str = Field(
+        default="fastlife.templating.renderer:JinjaxTemplateRenderer"
+    )
+    """
+    Implementation class for the :class:`fastlife.templatingAbstractTemplateRenderer`.
+    """
+    form_data_model_prefix: str = Field(default="payload")
+    """
+    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."""
+
+    jinjax_use_cache: bool = Field(default=True)
+    """
+    JinjaX (the default template engine) setting use_cache.
+
+    Could be disabled while developping, leave value true for production.
+    """
+    jinjax_auto_reload: bool = Field(default=False)
+    """
+    JinjaX (the default template engine) setting auto_reload.
+
+    Set to true while developing, set false for production.
+    """
+
+    session_secret_key: str = Field(default="")
+    """
+    A secret key, that could not changes for life.
+
+    Used to securize the session with itsdangerous.
+    """
+    session_cookie_name: str = Field(default="flsess")
+    """Cookie name for the session cookie."""
+    session_cookie_domain: str = Field(default="")
+    """Cookie domain for the session cookie."""
+    session_cookie_path: str = Field(default="/")
+    """Cookie path for the session cookie."""
+    session_duration: timedelta = Field(default=timedelta(days=14))
+    """Cookie duration for the session cookie."""
+    session_cookie_same_site: Literal["lax", "strict", "none"] = Field(default="lax")
+    """Cookie same-site for the session cookie."""
+    session_cookie_secure: bool = Field(default=False)
+    """
+    Cookie secure for the session cookie,
+
+    should be true while using https on production.
+    """
+    session_serializer: str = Field(
+        default="fastlife.session.serializer:SignedSessionSerializer"
+    )
+    """Cookie serializer for the session cookie."""
+
+    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."""

fastlifeweb-0.7.0/src/fastlife/routing/router.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+from fastapi import APIRouter
+
+from fastlife.configurator.route_handler import FastlifeRoute
+
+
+class FastLifeRouter(APIRouter):
+    """The router used split your app in many routes."""
+
+    def __init__(self, **kwargs: Any) -> None:
+        kwargs["route_class"] = FastlifeRoute
+        super().__init__(**kwargs)

{fastlifeweb-0.6.1 → fastlifeweb-0.7.0}/src/fastlife/security/csrf.py

@@ -1,3 +1,8 @@
+"""
+Prevents CSRF attack using cookie and html hidden field comparaison.
+
+Fast life did not reinvent the wheel on CSRF Protection. It use the good old method.
+"""
 import secrets
 from typing import TYPE_CHECKING, Any, Callable, Coroutine
 
@@ -8,14 +13,24 @@ if TYPE_CHECKING:
 
 
 class CSRFAttack(Exception):
-    ...
+    """
+    An exception raised if the cookie and the csrf token hidden field did not match.
+    """
 
 
 def create_csrf_token() -> str:
+    """A helper that create a csrf token."""
     return secrets.token_urlsafe(5)
 
 
 def check_csrf(registry: "Registry") -> Callable[[Request], Coroutine[Any, Any, bool]]:
+    """
+    A global application dependency, that is always active.
+
+    If you don't want csrf token, its simple don't use the
+    application/x-www-form-urlencoded on a POST method.
+    """
+
     async def check_csrf(request: Request) -> bool:
         if (
             request.method != "POST"

{fastlifeweb-0.6.1 → fastlifeweb-0.7.0}/src/fastlife/security/policy.py

@@ -1,3 +1,4 @@
+"""Security policy."""
 from typing import Any, Callable, Coroutine
 
 CheckPermissionHook = Callable[..., Coroutine[Any, Any, None]] | Callable[..., None]
@@ -6,10 +7,13 @@ CheckPermission = Callable[[str], CheckPermissionHook]
 
 def check_permission(permission_name: str) -> CheckPermissionHook:
     """
-    A closure that check that a user as the given username.
+    A closure that check that a user as the given permission_name.
 
     This method has to be overriden using the setting check_permission
     to implement it.
+
+    :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.
     """
 
     def depencency_injection() -> None:

{fastlifeweb-0.6.1 → fastlifeweb-0.7.0}/src/fastlife/templates/Button.jinja

@@ -12,6 +12,8 @@ hx_get="",
 hx_select="",
 hx_after_request="",
 hx_vals="",
+hx_confirm="",
+hx_delete="",
 full_width=false,
 class_="""
 bg-primary-600
@@ -33,9 +35,10 @@ dark:hover:bg-primary-700
 #}
 <button type="{{type}}" {%if id %}id="{{id}}" {%endif%} name="{{name}}" value="{{value}}" {% if
   hx_target%}hx-target="{{hx_target}}" {% endif %} {% if hx_swap %}hx-swap="{{hx_swap}}" {% endif %} {% if hx_select
-  %}hx-select="{{hx_select}}" {% endif %} {% if hx_get %}hx-get="{{hx_get}}" {% endif %} {% if onclick %}onclick="{{onclick}}" {%
-  endif %}{% if hx_after_request %}hx-on::after-request="{{hx_after_request}}" {% endif %} {% if hx_vals
-  %}hx-vals='{{hx_vals|safe}}' {% endif %} {% if aria_label %}aria-label="{{aria_label}}" {% endif %}
+  %}hx-select="{{hx_select}}" {% endif %} {% if hx_get %}hx-get="{{hx_get}}" {% endif %} {% if onclick
+  %}onclick="{{onclick}}" {% endif %}{% if hx_after_request %}hx-on::after-request="{{hx_after_request}}" {% endif %} {%
+  if hx_vals %}hx-vals='{{hx_vals|safe}}' {% endif %} {% if hx_confirm %}hx-confirm="{{hx_confirm}}" {% endif %} {% if
+  hx_delete %}hx-delete="{{hx_delete}}" {% endif %} {% if aria_label %}aria-label="{{aria_label}}" {% endif %}
   class="{% if full_width %}w-full {% endif %}{{attrs.class or class_}}" {% if hidden %}hidden{% endif %}>
   {{- content -}}
 </button>

{fastlifeweb-0.6.1 → fastlifeweb-0.7.0}/src/fastlife/templating/__init__.py

@@ -1,3 +1,7 @@
+"""
+Utilities for rendering HTML templates for page and components.
+"""
+
 from .binding import Template, template
 from .renderer import AbstractTemplateRendererFactory, JinjaxTemplateRenderer
 

{fastlifeweb-0.6.1 → fastlifeweb-0.7.0}/src/fastlife/templating/binding.py

@@ -38,4 +38,11 @@ def get_template(template: str, *, content_type: str = "text/html") -> TemplateE
 
 
 def template(template_path: str) -> Template:
+    """
+    Return a FastAPI dependency template engine ready to render the template.
+
+
+    :param template_path: path to template to render by the engine setup in the regitry.
+    :return: A callable accepting kwargs to pass as the context, returning a string.
+    """
     return Depends(get_template(template_path))

fastlifeweb-0.7.0/src/fastlife/templating/renderer/abstract.py

@@ -0,0 +1,107 @@
+import abc
+from typing import Any, Mapping, Optional, Type
+
+from fastapi import Request
+from markupsafe import Markup
+from pydantic.fields import FieldInfo
+
+from fastlife.request.model_result import ModelResult
+
+
+class AbstractTemplateRenderer(abc.ABC):
+    """
+    An object that will be initialized by an AbstractTemplateRendererFactory,
+    passing the request to process.
+    """
+
+    route_prefix: str
+    """Used to buid pydantic form"""
+
+    @abc.abstractmethod
+    def render_template(
+        self,
+        template: str,
+        *,
+        globals: Optional[Mapping[str, Any]] = None,
+        **params: Any,
+    ) -> str:
+        """
+        Render the given template with the given params.
+
+        While rendering templates, the globals parameter is keps by the instantiated
+        renderer and sent to every rendering made by the request.
+        This is used by the pydantic form method that will render other templates
+        for the request.
+        In traditional frameworks, only one template is rendered containing the whole
+        pages. But, while rendering a pydantic form, every field is rendered in its
+        distinct template. The template renderer keep the globals and git it back
+        to every templates. This can be used to fillout options in a select without
+        performing an ajax request for example.
+
+        :param template: name of the template to render
+        :param globals: some variable that will be passed to all rendered templates.
+        :param params: paramaters that are limited to the main rendered templates.
+        :return: The template rendering result.
+        """
+
+    @abc.abstractmethod
+    def pydantic_form(
+        self, model: ModelResult[Any], *, token: Optional[str] = None
+    ) -> Markup:
+        """
+        Render an http form from a given model.
+
+        Because template post may be give back to users with errors,
+        the model is wrap in an object containing initial model, or validated model
+        and a set of errors.
+
+        this function is used inside the template directly. And it will not render the
+        <form> tag so the action/httpx post is not handled byu the method..
+        Somethinging like this
+
+        ::
+
+            <form action="" method="post">
+                {{ pydantic_form(model) }}
+            </form>
+
+
+        :param model: model to render
+        :param token: a random string that can be passed for testing purpose.
+        """
+        ...
+
+    @abc.abstractmethod
+    def pydantic_form_field(
+        self,
+        model: Type[Any],
+        *,
+        name: str | None,
+        token: str | None,
+        removable: bool,
+        field: FieldInfo | None,
+    ) -> Markup:
+        """
+        Render a field of a model inside a pydantic_form.
+
+        Models that contains field of type Union, for instance may have
+        many types of children and the form have a user interaction to choose
+        which sub type to select. When the user choose the type, the sub model is
+        rendered using this helper under the hood.
+        """
+
+
+class AbstractTemplateRendererFactory(abc.ABC):
+    """
+    The template render factory.
+    """
+
+    @abc.abstractmethod
+    def __call__(self, request: Request) -> AbstractTemplateRenderer:
+        """
+        While processing an HTTP Request, a renderer object is created giving
+        isolated context per request.
+
+        :param Request: the HTTP Request to process.
+        :return: The renderer object that will process that request.
+        """

{fastlifeweb-0.6.1 → fastlifeweb-0.7.0}/src/fastlife/templating/renderer/jinjax.py

@@ -69,28 +69,18 @@ class JinjaxRenderer(AbstractTemplateRenderer):
         )
 
     def pydantic_form(
-        self,
-        model: ModelResult[Any],
-        *,
-        name: Optional[str] = None,
-        token: Optional[str] = None,
-        removable: bool = False,
-        field: FieldInfo | None = None,
+        self, model: ModelResult[Any], *, token: Optional[str] = None
     ) -> Markup:
-        return WidgetFactory(self, token).get_markup(
-            model,
-            removable=removable,
-            field=field,
-        )
+        return WidgetFactory(self, token).get_markup(model)
 
     def pydantic_form_field(
         self,
         model: Type[Any],
         *,
-        name: Optional[str] = None,
-        token: Optional[str] = None,
-        removable: bool = False,
-        field: FieldInfo | None = None,
+        name: str | None,
+        token: str | None,
+        removable: bool,
+        field: FieldInfo | None,
     ) -> Markup:
         return (
             WidgetFactory(self, token)
@@ -107,6 +97,12 @@ class JinjaxRenderer(AbstractTemplateRenderer):
 
 
 class JinjaxTemplateRenderer(AbstractTemplateRendererFactory):
+    """
+    The default template renderer factory. Based on JinjaX.
+
+    :param settings: setting used to configure jinjax.
+    """
+
     route_prefix: str
     """Used to prefix url to fetch fast life widgets."""
 
@@ -123,6 +119,7 @@ class JinjaxTemplateRenderer(AbstractTemplateRendererFactory):
             self.catalog.add_folder(path)
 
     def __call__(self, request: Request) -> AbstractTemplateRenderer:
+        """Build the renderer to render request for template."""
         return JinjaxRenderer(
             self.catalog,
             request,

{fastlifeweb-0.6.1 → fastlifeweb-0.7.0}/src/fastlife/templating/renderer/widgets/factory.py

@@ -35,7 +35,7 @@ class WidgetFactory:
         self,
         model: ModelResult[Any],
         *,
-        removable: bool,
+        removable: bool = False,
         field: FieldInfo | None = None,
     ) -> Markup:
         return self.get_widget(

{fastlifeweb-0.6.1 → fastlifeweb-0.7.0}/src/fastlife/testing/__init__.py

@@ -1,3 +1,4 @@
+"""Testing fastlife client."""
 from .testclient import WebTestClient
 
 __all__ = ["WebTestClient"]

{fastlifeweb-0.6.1 → fastlifeweb-0.7.0}/src/fastlife/testing/testclient.py

@@ -342,6 +342,9 @@ class WebForm:
         """Test if a field exists in the form."""
         return key in self._formdata
 
+    def __repr__(self) -> str:
+        return repr(self._formdata)
+
 
 class WebResponse:
     """Represent an http response made by the WebTestClient browser."""
@@ -511,7 +514,7 @@ class WebTestClient:
 
     def request(
         self,
-        method: Literal["GET", "POST"],  # I am a browser
+        method: Literal["GET", "POST", "DELETE"],
         url: str,
         *,
         content: str | None = None,
@@ -562,6 +565,14 @@ class WebTestClient:
             max_redirects=int(follow_redirects) * 10,
         )
 
+    def delete(self, url: str, follow_redirects: bool = True) -> WebResponse:
+        """Perform http DELETE request."""
+        return self.request(
+            "DELETE",
+            url,
+            max_redirects=int(follow_redirects) * 10,
+        )
+
     def post(
         self,
         url: str,

{fastlifeweb-0.6.1 → fastlifeweb-0.7.0}/src/fastlife/views/pydantic_form.py

@@ -17,6 +17,9 @@ async def show_widget(
     token: Optional[str] = Query(None),
     removable: bool = Query(False),
 ) -> Response:
+    """
+    This views is used by pydantic_form to generate a nested field asynchronously.
+    """
     model_cls = resolve_extended(typ)
     field = None
     if title:

fastlifeweb-0.6.1/src/fastlife/configurator/settings.py

@@ -1,36 +0,0 @@
-from datetime import timedelta
-from typing import Literal
-
-from pydantic import Field
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-
-class Settings(BaseSettings):
-    model_config = SettingsConfigDict(env_prefix="fastlife_")
-
-    fastlife_route_prefix: str = Field(default="/_fl")
-    template_search_path: str = Field(default="fastlife:templates")
-    registry_class: str = Field(default="fastlife.configurator.registry:AppRegistry")
-    template_renderer_class: str = Field(
-        default="fastlife.templating.renderer:JinjaxTemplateRenderer"
-    )
-    form_data_model_prefix: str = Field(default="payload")
-    csrf_token_name: str = Field(default="csrf_token")
-
-    jinjax_use_cache: bool = Field(default=True)
-    jinjax_auto_reload: bool = Field(default=False)
-
-    session_secret_key: str = Field(default="")
-    session_cookie_name: str = Field(default="flsess")
-    session_cookie_domain: str = Field(default="")
-    session_cookie_path: str = Field(default="/")
-    session_duration: timedelta = Field(default=timedelta(days=14))
-    session_cookie_same_site: Literal["lax", "strict", "none"] = Field(default="lax")
-    session_cookie_secure: bool = Field(default=False)
-    session_serializer: str = Field(
-        default="fastlife.session.serializer:SignedSessionSerializer"
-    )
-
-    domain_name: str = Field(default="", title="domain name where the app is served")
-
-    check_permission: str = Field(default="fastlife.security.policy:check_permission")

fastlifeweb-0.6.1/src/fastlife/templating/renderer/abstract.py

@@ -1,60 +0,0 @@
-import abc
-from typing import Any, Mapping, Optional, Type
-
-from fastapi import Request
-from markupsafe import Markup
-from pydantic.fields import FieldInfo
-
-from fastlife.request.model_result import ModelResult
-
-
-class AbstractTemplateRenderer(abc.ABC):
-    route_prefix: str
-    """Used to buid pydantic form"""
-
-    @abc.abstractmethod
-    def render_template(
-        self,
-        template: str,
-        *,
-        globals: Optional[Mapping[str, Any]] = None,
-        **params: Any,
-    ) -> str:
-        """
-        Render the given template with the given params.
-
-        While rendering templates, the globals parameter is keps by the instantiated
-        renderer and sent to every rendering made by the request.
-        This is used by the pydantic form method that will render other templates
-        for the request.
-        """
-
-    @abc.abstractmethod
-    def pydantic_form(
-        self,
-        model: ModelResult[Any],
-        *,
-        name: str | None = None,
-        token: str | None = None,
-        removable: bool = False,
-        field: FieldInfo | None = None,
-    ) -> Markup:
-        ...
-
-    @abc.abstractmethod
-    def pydantic_form_field(
-        self,
-        model: Type[Any],
-        *,
-        name: Optional[str] = None,
-        token: Optional[str] = None,
-        removable: bool = False,
-        field: FieldInfo | None = None,
-    ) -> Markup:
-        ...
-
-
-class AbstractTemplateRendererFactory(abc.ABC):
-    @abc.abstractmethod
-    def __call__(self, request: Request) -> AbstractTemplateRenderer:
-        ...