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

fastlife/components/pydantic_form/Hidden.jinja

@@ -1,3 +0,0 @@
-{# doc Render a hidden input field for a field. #}
-{# def widget: Annotated[fastlife.adapters.jinjax.widgets.hidden.HiddenWidget, "widget to display."] #}
-<Hidden :name="widget.name" :value="widget.value" :id="widget.id" />

fastlife/components/pydantic_form/Model.jinja

@@ -1,30 +0,0 @@
-{# doc Widget for pydantic BaseModel subclasses. #}
-{# def
-    widget: Annotated[fastlife.adapters.jinjax.widgets.model.ModelWidget, "widget to display."],
-    children_widget : Annotated[
-        Sequence[fastlife.adapters.jinjax.widgets.base.Widget],
-        "child widgets for every fields of the model."
-    ],
-#}
-
-<pydantic_form.Widget :widget="widget">
-  <div id="{{widget.id}}"{% if widget.nested %} class="m-4"{%endif%}>
-    {% if widget.nested %}
-    <Details>
-      <Summary :id="widget.id + '-summary'">
-        <H3 :class="H3_SUMMARY_CLASS">{{widget.title}}</H3>
-        <pydantic_form.Error :text="widget.error" />
-      </Summary>
-      <div>
-        {% for child in children_widget %}
-        {{ child }}
-        {% endfor %}
-      </div>
-    </Details>
-    {% else %}
-        {% for child in children_widget %}
-        {{ child }}
-        {% endfor %}
-    {% endif %}
-  </div>
-</pydantic_form.Widget>

fastlife/components/pydantic_form/Sequence.jinja

@@ -1,47 +0,0 @@
-{# doc Widget for pydantic BaseModel subclasses. #}
-{# def
-    widget: Annotated[fastlife.adapters.jinjax.widgets.sequence.SequenceWidget, "widget to display."],
-    children_widgets : Annotated[
-        Sequence[fastlife.adapters.jinjax.widgets.base.Widget],
-        "child widgets for every fields of the model."
-    ],
-    type: Annotated[fastlife.adapters.jinjax.widgets.base.TypeWrapper, "child type wrapped."]
-#}
-
-<pydantic_form.Widget :widget="widget">
-  <Details :id="widget.id">
-    <Summary :id="widget.id + '-summary'">
-      <H3 :class="H3_SUMMARY_CLASS">{{widget.title}}</H3>
-      <pydantic_form.Error :text="widget.error" />
-    </Summary>
-    <div>
-      {% set fnGetName = "get" + widget.id.replace("-", "_") %}
-      <script>
-        function {{ fnGetName }} () {
-          const el = document.getElementById("{{widget.id}}-content");
-          const len = el.dataset.length;
-          el.dataset.length = parseInt(len) + 1;
-          return "{{type.name}}." + len;
-        }
-      </script>
-
-      <div id="{{widget.id}}-content" class="m-4" data-length="{{children_widgets|length|string}}">
-        {% set container_id = widget.id + "-children-container" %}
-        <div id="{{container_id}}">
-          {% for child in children_widgets %}
-          {{ child }}
-          {% endfor%}
-        </div>
-      </div>
-
-      <div>
-        {% set container_id = "#" + widget.id + "-children-container" %}
-        {% set add_id = widget.id + "-add" %}
-        {% set vals = 'js:{"name": '+ fnGetName + '(), "token": "' + type.token + '", "removable": true}' %}
-        <Button type="button" :hx-target="container_id" hx-swap="beforeend" :id="add_id" :hx-vals="vals" :hx-get="type.url">
-          Add
-        </Button>
-      </div>
-    </div>
-  </Details>
-</pydantic_form.Widget>

fastlife/components/pydantic_form/Text.jinja

@@ -1,11 +0,0 @@
-{# def widget: Annotated[fastlife.adapters.jinjax.widgets.text.TextWidget, "widget to display."] #}
-
-<pydantic_form.Widget :widget="widget">
-  <div class="pt-4">
-    <Label :for="widget.id">{{widget.title}}</Label>
-    <pydantic_form.Error :text="widget.error" />
-    <Input :name="widget.name" :value="widget.value" :type="widget.input_type" :id="widget.id"
-      :aria-label="widget.aria_label" :placeholder="widget.placeholder" />
-    <pydantic_form.Hint :text="widget.hint" />
-  </div>
-</pydantic_form.Widget>

fastlife/components/pydantic_form/Textarea.jinja

@@ -1,38 +0,0 @@
-{# doc
-Render textarea widget for field of type text of event sequence.
-
-::
-
-    from fastlife.adapters.jinjax.widgets.text import TextareaWidget
-    from pydantic import BaseModel, Field, field_validator
-
-    class TagsForm(BaseModel):
-
-        tags: Annotated[Sequence[str], TextareaWidget] = Field(
-            default_factory=list,
-            title="Tags",
-            description="One tag per line",
-        )
-
-        @field_validator("tags", mode="before")
-        def split(cls, s: Any) -> Sequence[str]:
-            return s.split() if s else []
-
- #}
-{# def widget: Annotated[fastlife.adapters.jinjax.widgets.text.TextareaWidget, "widget to display."] #}
-
-<pydantic_form.Widget :widget="widget">
-  <div class="pt-4">
-    <Label :for="widget.id">{{widget.title}}</Label>
-    <pydantic_form.Error :text="widget.error" />
-    <Textarea :name="widget.name" :id="widget.id" :aria-label="widget.aria_label">
-        {%- if v is string -%}
-        {{- v -}}}
-        {%- else -%}
-        {%- for v in widget.value %}{{v}}
-{% endfor -%}
-        {% endif %}
-    </Textarea>
-    <pydantic_form.Hint :text="widget.hint" />
-  </div>
-</pydantic_form.Widget>

fastlife/components/pydantic_form/Union.jinja

@@ -1,34 +0,0 @@
-{# doc display widget for union type field #}
-{# def
-widget: Annotated[fastlife.adapters.jinjax.widgets.base.Widget, "widget to display."],
-child: Annotated[fastlife.adapters.jinjax.widgets.base.Widget, "current widget if any"],
-types: Annotated[Sequence[fastlife.adapters.jinjax.widgets.base.TypeWrapper], "Child types to choose"],
-parent_type: Annotated[fastlife.adapters.jinjax.widgets.base.TypeWrapper, "parent type"]
-#}
-
-<pydantic_form.Widget :widget="widget">
-  <div id="{{widget.id}}">
-    <Details>
-      <Summary :id="widget.id + '-union-summary'">
-        <H3 :class="H3_SUMMARY_CLASS">{{widget.title}}</H3>
-        <pydantic_form.Error :text="widget.error" />
-      </Summary>
-      <div hx-sync="this" id="{{widget.id}}-child">
-        {% if child %}
-        {{ child }}
-        {% else %}
-        {% for typ in types %}
-        <Button type="button" hx-target="closest div" :hx-get="typ.url" :hx-vals="typ.params|tojson" :id="typ.id"
-          onclick={{ "document.getElementById('" + widget.id + "-remove-btn').hidden=false" }}
-          :class="SECONDARY_BUTTON_CLASS">{{typ.title}}</Button>
-        {% endfor %}
-        {% endif %}
-      </div>
-      <Button type="button" :id="widget.id + '-remove-btn'" :hx-target="'#' + widget.id"
-        :hx-vals="parent_type.params|tojson" :hx-get="parent_type.url" :hidden="not child"
-        :class="SECONDARY_BUTTON_CLASS">
-        Remove
-      </Button>
-    </Details>
-  </div>
-</pydantic_form.Widget>

fastlife/request/__init__.py

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

fastlife/security/__init__.py

@@ -1 +0,0 @@
-"""Security features."""

fastlife/security/policy.py

@@ -1,188 +0,0 @@
-"""Security policy."""
-
-import abc
-import logging
-from collections.abc import Callable, Coroutine
-from typing import Annotated, Any, Generic, Literal, TypeVar
-from uuid import UUID
-
-from fastapi import Depends, HTTPException
-from starlette.status import HTTP_401_UNAUTHORIZED, HTTP_403_FORBIDDEN
-
-from fastlife import GenericRequest, get_request
-from fastlife.config.registry import TRegistry
-
-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):
-    """
-    A type used to know if a permission is allowed or not.
-
-    It behave has a boolean, but 3 possibilities exists defind has 3 sub-types
-    {class}`Allowed` {class}`Unauthenticated` or {class}`Denied`.
-
-    In many cases Unauthenticated call may redirect to a login page,
-    where authenticated user are not redirected. they have an error message,
-    or the frontend may use the information to adapt its interface.
-    """
-
-    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"
-
-
-class Unauthenticated(HasPermission):
-    """
-    Represent a permission check result that is not allowed due to
-    missing authentication mechanism.
-    """
-
-    kind = "unauthenticated"
-    reason = "Authentication required"
-
-
-class Denied(HasPermission):
-    """
-    Represent a permission check result that is not allowed due to lack of permission.
-    """
-
-    kind = "denied"
-    reason = "Access denied to this resource"
-
-
-class AbstractSecurityPolicy(abc.ABC, Generic[TUser, TRegistry]):
-    """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."""
-
-    request: GenericRequest[TRegistry]
-    """Request where the security policy is applied."""
-
-    def __init__(
-        self, request: Annotated[GenericRequest[TRegistry], Depends(get_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, Any]):
-    """
-    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."""
-
-    async def forget(self) -> None:
-        """Do nothing."""

fastlife/templates/__init__.py

@@ -1,12 +0,0 @@
-"""
-Utilities for rendering HTML templates for page and components as FastAPI dependencies.
-"""
-
-from .binding import Template, template
-from .inline import InlineTemplate
-
-__all__ = [
-    "Template",
-    "template",
-    "InlineTemplate",
-]

fastlife/templates/binding.py

@@ -1,52 +0,0 @@
-"""
-Bind template to the view in order to build an html response.
-"""
-
-from collections.abc import Callable
-from typing import Any
-
-from fastapi import Depends, Response
-
-from fastlife.request import Request
-from fastlife.security.csrf import create_csrf_token
-
-Template = Callable[..., Response]
-"""Type to annotate a FastAPI depency injection."""
-
-TemplateEngine = Callable[[Request], Template]
-
-
-def get_template(template: str, *, content_type: str = "text/html") -> TemplateEngine:
-    """
-    Return a closure to render the given template.
-
-    :param template: path to template to render.
-    :param content_type: response ``Content-Type`` header.
-    """
-
-    def render_template(
-        request: Request,
-        *,
-        _create_csrf_token: Callable[..., str] = create_csrf_token,
-    ) -> Template:
-        reg = request.registry
-
-        def parametrizer(**kwargs: Any) -> Response:
-            return reg.get_renderer(template)(request).render(
-                template, content_type=content_type, params=kwargs
-            )
-
-        return parametrizer
-
-    return render_template
-
-
-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))