fastlifeweb 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

fastlife/configurator/configurator.py

@@ -21,7 +21,7 @@ from typing import (
 
 import venusian  # type: ignore
 from fastapi import Depends, FastAPI, Response
-from fastapi.datastructures import Default
+from fastapi.params import Depends as DependsType
 from fastapi.staticfiles import StaticFiles
 
 from fastlife.configurator.base import AbstractMiddleware
@@ -69,20 +69,21 @@ class Configurator:
 
     def add_route(
         self,
+        name: str,
         path: str,
         endpoint: Callable[..., Coroutine[Any, Any, Response]],
         *,
-        response_model: Any = Default(None),
-        status_code: Optional[int] = None,
-        tags: Optional[List[Union[str, Enum]]] = None,
-        # dependencies: Optional[Sequence[Depends]] = None,  # type: ignore
+        permission: str | None = None,
+        status_code: int | None = None,
+        tags: List[Union[str, Enum]] | None = None,
         summary: Optional[str] = None,
         description: Optional[str] = None,
-        # response_description: str = "Successful Response",
+        response_description: str = "Successful Response",
         # responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
         deprecated: Optional[bool] = None,
         methods: Optional[List[str]] = None,
-        operation_id: Optional[str] = None,
+        # operation_id: Optional[str] = None,
+        # response_model: Any = Default(None),
         # response_model_include: Optional[IncEx] = None,
         # response_model_exclude: Optional[IncEx] = None,
         # response_model_by_alias: bool = True,
@@ -93,26 +94,29 @@ class Configurator:
         # response_class: Union[Type[Response], DefaultPlaceholder] = Default(
         #     HTMLResponse
         # ),
-        name: Optional[str] = None,
         # openapi_extra: Optional[Dict[str, Any]] = None,
         # generate_unique_id_function: Callable[[APIRoute], str] = Default(
         #     generate_unique_id
         # ),
     ) -> "Configurator":
+        dependencies: List[DependsType] = []
+        if permission:
+            dependencies.append(Depends(self.registry.check_permission(permission)))
+
         self._app.add_api_route(
             path,
             endpoint,
-            response_model=response_model,
+            # response_model=response_model,
             status_code=status_code,
             tags=tags,
-            # dependencies=dependencies,
+            dependencies=dependencies,
             summary=summary,
             description=description,
-            # response_description=response_description,
+            response_description=response_description,
             # responses=responses,
             deprecated=deprecated,
             methods=methods,
-            operation_id=operation_id,
+            # operation_id=operation_id,
             # response_model_include=response_model_include,
             # response_model_exclude=response_model_exclude,
             # response_model_by_alias=response_model_by_alias,
@@ -134,6 +138,12 @@ class 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":
+        self._app.add_exception_handler(status_code_or_exc, handler)
+        return self
+
 
 def configure(
     wrapped: Callable[[Configurator], None]

fastlife/configurator/registry.py

@@ -2,6 +2,7 @@ from typing import Annotated
 
 from fastapi import Depends
 
+from fastlife.security.policy import CheckPermission
 from fastlife.shared_utils.resolver import resolve
 from fastlife.templating.renderer import AbstractTemplateRenderer
 
@@ -11,11 +12,15 @@ from .settings import Settings
 class AppRegistry:
     settings: Settings
     renderer: AbstractTemplateRenderer
+    check_permission: CheckPermission
 
     def __init__(self, settings: Settings) -> None:
+        # Abtract class resolved for dependency injection
         TemplateRenderer = resolve(settings.template_renderer_class)
+
         self.settings = settings
         self.renderer = TemplateRenderer(settings)
+        self.check_permission = resolve(settings.check_permission)
 
 
 DEFAULT_REGISTRY: AppRegistry = None  # type: ignore

fastlife/configurator/settings.py

@@ -19,6 +19,7 @@ class Settings(BaseSettings):
 
     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")
@@ -28,3 +29,5 @@ class Settings(BaseSettings):
     )
 
     domain_name: str = Field(default="", title="domain name where the app is served")
+
+    check_permission: str = Field(default="fastlife.security.policy:check_permission")

fastlife/security/policy.py

@@ -0,0 +1,18 @@
+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 username.
+
+    This method has to be overriden using the setting check_permission
+    to implement it.
+    """
+
+    def depencency_injection() -> None:
+        ...
+
+    return depencency_injection

fastlife/session/__init__.py

@@ -17,6 +17,6 @@ def includeme(config: Configurator) -> None:
             cookie_path=settings.session_cookie_path,
             cookie_same_site=settings.session_cookie_same_site,
             cookie_secure=settings.session_cookie_secure,
-            cookie_domain=settings.domain_name,
+            cookie_domain=settings.session_cookie_domain,
             serializer=session_serializer,
         )

fastlife/session/middleware.py

@@ -41,16 +41,18 @@ class SessionMiddleware(AbstractMiddleware):
             return
 
         connection = HTTPConnection(scope)
-        reset_session = False
-
-        if self.cookie_name in connection.cookies:
+        existing_session = self.cookie_name in connection.cookies
+        if existing_session:
             data = connection.cookies[self.cookie_name].encode("utf-8")
-            scope["session"], reset_session = self.serializer.deserialize(data)
+            scope["session"], broken_session = self.serializer.deserialize(data)
+            if broken_session:
+                existing_session = False
         else:
             scope["session"] = {}
 
         async def send_wrapper(message: Message) -> None:
             if message["type"] == "http.response.start":
+                headers = None
                 if scope["session"]:
                     # We have session data to persist.
                     data = self.serializer.serialize(scope["session"]).decode("utf-8")
@@ -60,7 +62,7 @@ class SessionMiddleware(AbstractMiddleware):
                         f"Max-Age={self.max_age}; {self.security_flags}"
                     )
                     headers.append("set-cookie", header_value)
-                elif reset_session:
+                elif existing_session:
                     # The session has been cleared.
                     headers = MutableHeaders(scope=message)
                     expires = "expires=Thu, 01 Jan 1970 00:00:00 GMT; "

fastlife/session/serializer.py

@@ -34,6 +34,11 @@ class SignedSessionSerializer(AbsractSessionSerializer):
     def deserialize(self, data: bytes) -> Tuple[Mapping[str, Any], bool]:
         try:
             data = self.signer.unsign(data, max_age=self.max_age)
+            # We can't deserialize something wrong since the serialize
+            # is signing the content.
+            # If the signature key is compromise and we have invalid payload,
+            # raising exceptions here is fine, it's dangerous afterall.
+            session = json.loads(b64decode(data))
         except itsdangerous.BadSignature:
             return {}, True
-        return json.loads(b64decode(data)), False
+        return session, False

fastlife/testing/testclient.py

@@ -1,4 +1,5 @@
 import re
+import time
 from collections.abc import MutableMapping
 from typing import Any, Literal, Mapping
 from urllib.parse import urlencode
@@ -13,13 +14,60 @@ from fastlife.session.serializer import AbsractSessionSerializer
 from fastlife.shared_utils.resolver import resolve
 
 
+class Element:
+    def __init__(self, client: "WebTestClient", tag: bs4.Tag):
+        self._client = client
+        self._tag = tag
+
+    def click(self) -> "WebResponse":
+        return self._client.get(self._tag.attrs["href"])
+
+    @property
+    def attrs(self) -> dict[str, str]:
+        return self._tag.attrs
+
+    @property
+    def form(self) -> "Element | None":
+        return Element(self._client, self._tag.form) if self._tag.form else None
+
+    def by_text(self, text: str, *, node_name: str | None = None) -> "Element | None":
+        nodes = self._tag.find_all(string=re.compile(rf"\s*{text}\s*"))
+        for node in nodes:
+            if isinstance(node, bs4.NavigableString):
+                node = node.parent
+
+            if node_name:
+                while node is not None:
+                    if node.name == node_name:
+                        return Element(self._client, node)
+                    node = node.parent
+            elif node:
+                return Element(self._client, node)
+        return None
+
+    def by_label_text(self, text: str) -> "Element | None":
+        label = self.by_text(text, node_name="label")
+        assert label is not None
+        assert label.attrs.get("for") is not None
+        resp = self._tag.find(id=label.attrs["for"])
+        assert not isinstance(resp, bs4.NavigableString)
+        return Element(self._client, resp) if resp else None
+
+    def by_node_name(
+        self, node_name: str, *, attrs: dict[str, str] | None = None
+    ) -> list["Element"]:
+        return [
+            Element(self._client, e) for e in self._tag.find_all(node_name, attrs or {})
+        ]
+
+
 class WebForm:
-    def __init__(self, client: "WebTestClient", origin: str, form: bs4.Tag):
+    def __init__(self, client: "WebTestClient", origin: str, form: Element):
         self._client = client
         self._form = form
         self._origin = origin
         self._formdata: dict[str, str] = {}
-        inputs = self._form.find_all("input")
+        inputs = self._form.by_node_name("input")
         for input in inputs:
             if input.attrs.get("type") == "checkbox" and "checked" not in input.attrs:
                 continue
@@ -32,7 +80,7 @@ class WebForm:
         self._formdata[fieldname] = value
 
     def button(self, text: str) -> "WebForm":
-        assert self._form.find("button", string=re.compile(f".*{text}.*")) is not None
+        assert self._form.by_text(text, node_name="button") is not None
         return self
 
     def submit(self, follow_redirects: bool = True) -> "WebResponse":
@@ -45,6 +93,9 @@ class WebForm:
             target, data=self._formdata, follow_redirects=follow_redirects
         )
 
+    def __contains__(self, key: str) -> bool:
+        return key in self._formdata
+
 
 class WebResponse:
     def __init__(self, client: "WebTestClient", origin: str, response: httpx.Response):
@@ -75,39 +126,16 @@ class WebResponse:
         return self._response.text
 
     @property
-    def html(self) -> bs4.Tag:
+    def html(self) -> Element:
         if self._html is None:
             self._html = bs4.BeautifulSoup(self._response.text, "html.parser")
-        return self._html
+        return Element(self._client, self._html)
 
     @property
-    def html_body(self) -> bs4.Tag:
-        body = self.html.find("body")
-        assert body is not None
-        assert isinstance(body, bs4.Tag)
-        return body
-
-    def by_text(self, text: str, *, node_name: str | None = None) -> bs4.Tag | None:
-        nodes = self.html.find_all(string=re.compile(rf"\s*{text}\s*"))
-        for node in nodes:
-            if isinstance(node, bs4.NavigableString):
-                node = node.parent
-
-            if node_name:
-                while node is not None:
-                    if node.name == node_name:
-                        return node
-                    node = node.parent
-
-        return None
-
-    def by_label_text(self, text: str) -> bs4.Tag | None:
-        label = self.by_text(text, node_name="label")
-        assert label is not None
-        assert label.attrs.get("for") is not None
-        resp = self.html.find(id=label.attrs["for"])
-        assert not isinstance(resp, bs4.NavigableString)
-        return resp
+    def html_body(self) -> Element:
+        body = self.html.by_node_name("body")
+        assert len(body) == 1
+        return body[0]
 
     @property
     def form(self) -> WebForm:
@@ -117,10 +145,16 @@ class WebResponse:
             self._form = WebForm(self._client, self._origin, form)
         return self._form
 
+    def by_text(self, text: str, *, node_name: str | None = None) -> Element | None:
+        return self.html.by_text(text, node_name=node_name)
+
+    def by_label_text(self, text: str) -> Element | None:
+        return self.html.by_label_text(text)
+
     def by_node_name(
         self, node_name: str, *, attrs: dict[str, str] | None = None
-    ) -> list[bs4.Tag]:
-        return self.html.find_all(node_name, attrs or {})
+    ) -> list[Element]:
+        return self.html.by_node_name(node_name, attrs=attrs)
 
 
 CookieTypes = httpx._types.CookieTypes  # type: ignore
@@ -141,28 +175,51 @@ class Session(dict[str, Any]):
         assert settings is not None
         self.settings = settings
         data: Mapping[str, Any]
-        if settings.session_cookie_name in self.client.cookies:
-            data, exists = self.srlz.deserialize(
+        self.has_session = settings.session_cookie_name in self.client.cookies
+        if self.has_session:
+            data, error = self.srlz.deserialize(
                 self.client.cookies[settings.session_cookie_name].encode("utf-8")
             )
+            if error:
+                self.has_session = False
         else:
-            data, exists = {}, False
-        self.new_session = not exists
+            data = {}
         super().__init__(data)
 
     def __setitem__(self, __key: Any, __value: Any) -> None:
         super().__setitem__(__key, __value)
         settings = self.settings
         data = self.serialize()
-        if self.new_session:
-            self.client.cookies.set(
-                settings.session_cookie_name,
-                data,
-                settings.domain_name,
-                settings.session_cookie_path,
+        from http.cookiejar import Cookie
+
+        self.client.cookies.jar.set_cookie(
+            Cookie(
+                version=0,
+                name=settings.session_cookie_name,
+                value=data,
+                port=None,
+                port_specified=False,
+                domain=f".{settings.session_cookie_domain}",
+                domain_specified=True,
+                domain_initial_dot=True,
+                path="/",
+                path_specified=True,
+                secure=False,
+                expires=int(time.time() + settings.session_duration.total_seconds()),
+                discard=False,
+                comment=None,
+                comment_url=None,
+                rest={"HttpOnly": None, "SameSite": "lax"},  # type: ignore
+                rfc2109=False,
             )
-        else:
-            self.client.cookies[settings.session_cookie_name] = data
+        )
+        # this does not work
+        # self.client.cookies.set(
+        #     settings.session_cookie_name,
+        #     data,
+        #     settings.session_cookie_domain,
+        #     settings.session_cookie_path,
+        # )
 
     def serialize(self) -> str:
         return self.srlz.serialize(self).decode("utf-8")
@@ -177,7 +234,12 @@ class WebTestClient:
         cookies: CookieTypes | None = None,
     ) -> None:
         self.app = app
-        self.testclient = TestClient(app, cookies=cookies or {})
+        if settings is None:
+            settings = Settings()
+            settings.domain_name = settings.domain_name or "testserver.local"
+        self.testclient = TestClient(
+            app, base_url=f"http://{settings.domain_name}", cookies=cookies or {}
+        )
         self.settings = settings
         self.session_serializer: AbsractSessionSerializer | None = None
         if settings:
@@ -212,7 +274,7 @@ class WebTestClient:
             url=url,
             headers=headers,
             content=content,
-            follow_redirects=False,  # don't follow for cookie processing
+            follow_redirects=False,
         )
         resp = WebResponse(
             self,

fastlife/views/pydantic_form.py

@@ -23,5 +23,8 @@ async def show_widget(
 def includeme(config: Configurator) -> None:
     route_prefix = config.registry.settings.fastlife_route_prefix
     config.add_route(
-        f"{route_prefix}/pydantic-form/widgets/{{typ}}", show_widget, methods=["GET"]
+        "fl-pydantic-form-widget",
+        f"{route_prefix}/pydantic-form/widgets/{{typ}}",
+        show_widget,
+        methods=["GET"],
     )

{fastlifeweb-0.2.0.dist-info → fastlifeweb-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastlifeweb
-Version: 0.2.0
+Version: 0.2.2
 Summary: High-level web framework
 License: BSD-derived
 Author: Guillaume Gauvrit
@@ -30,6 +30,11 @@ 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)
+
+
 A high-level Python web framework based on FastAPI, Jinja2 and Pydandic and htmx.
 
 The intention is to prototype fast application.

{fastlifeweb-0.2.0.dist-info → fastlifeweb-0.2.2.dist-info}/RECORD

@@ -1,17 +1,18 @@
 fastlife/__init__.py,sha256=__RsTYXTkhcxwHRvT1xWQ5XfygdwBtotbrff71lu-kk,190
 fastlife/configurator/__init__.py,sha256=2EPjM1o5iHJIViPwgJjaPQS3pMhE-9dik_mm53eX2DY,91
 fastlife/configurator/base.py,sha256=2ahvTudLmD99YQjnIeGN5JDPCSl3k-mauu7bsSEB5RE,216
-fastlife/configurator/configurator.py,sha256=3LMeHFhQxCVFDFgAJLSVv8BJJqc5-J-gsnWARJoM-2I,5155
-fastlife/configurator/registry.py,sha256=YRewgqw6FoKHa3vjliwm2_XshydJKPJL_IAnvldfp3o,1115
-fastlife/configurator/settings.py,sha256=lNgp_jBfzgXGxoXaW7iey5VNdf9D6AGhimYPNwiLjF0,1255
+fastlife/configurator/configurator.py,sha256=SfzHlS6ou2JrUhzm0Q--G8R_XGo4nARQO-Mwzy-Mfn4,5474
+fastlife/configurator/registry.py,sha256=fSwlfeqrVzLJmaR2-bAu41rJP8uRMZd-8vZnfsfN2xg,1332
+fastlife/configurator/settings.py,sha256=ui40ldu3f6v9ARDVijhNcD2AxF1fWFbfOkkZ7z_2gH0,1394
 fastlife/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastlife/request/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastlife/request/form_data.py,sha256=7gV2hLeFyhPRrNYL_UlRAqM-oqxSu2-VvxKHMv5F900,3849
 fastlife/security/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastlife/security/csrf.py,sha256=-2XVfkSpmU1HJB2-_tZiOmqs9KLtib0tb_l1QbIFj34,1005
-fastlife/session/__init__.py,sha256=0BIArO93ylDlHhVUNyAv7UfVuh9nO9YRUh0YvNDc-IM,828
-fastlife/session/middleware.py,sha256=kCPQY8nODX1kXPDJzhgyZF4IIT4soG8WS7EqSYn2vEk,2930
-fastlife/session/serializer.py,sha256=3VwDafQ_dXttlf3Dj2WULhV0PVDBy0EvetVYpdcThM8,1169
+fastlife/security/policy.py,sha256=5jV5nypy5O8XPFFRJ_bzG8Ltk5xcPWclkz23qiG1_I8,509
+fastlife/session/__init__.py,sha256=OnzRCYRzc1lw9JB0UdKi-aRLPNT2n8mM8kwY1P4w7uU,838
+fastlife/session/middleware.py,sha256=tz5ANgTKXaIqXGaqNM9czfSRdkfwRChODmKAqWGzP60,3050
+fastlife/session/serializer.py,sha256=qpVnHQjYTxw3aOnoEOKIjOFJg2z45KjiX5sipWk2gws,1458
 fastlife/shared_utils/infer.py,sha256=_hmGzu84VlZAkdw_owkW8eHknULqH3MLDBlXj7LkEsc,466
 fastlife/shared_utils/resolver.py,sha256=cZYcaV27sIC5vLc_xo-yj0S3nTimeY5KRZTanHY6e_Y,1295
 fastlife/templates/base.jinja2,sha256=JOHL2bexmNfaRwStdOnd_oLW1YhKnhQbNQfVItMVBkM,112
@@ -40,10 +41,10 @@ fastlife/templating/renderer/widgets/sequence.py,sha256=b2e7YOU4BCASJ46peYtSaaoq
 fastlife/templating/renderer/widgets/text.py,sha256=6sQ9tlmWVn8-bogSbb8m2gAL-1Lrkb026W5ekez4Jlc,789
 fastlife/templating/renderer/widgets/union.py,sha256=pT_Mcrb-_ZTZV3ZPkyQYdEW2AE3PglojXdYaMfrgZ0k,1645
 fastlife/testing/__init__.py,sha256=KgTlRI0g8z7HRpL7mD5QgI__LT9Y4QDSzKMlxJG3wNk,67
-fastlife/testing/testclient.py,sha256=p1VwviwQT4xstJSWejtuBvHDwmeqNCjwLvWLtkkCl-I,7979
+fastlife/testing/testclient.py,sha256=GBSL9xECrLf4jkFiZCT2h0NajFNBSVuFY4zm5MyolBw,10095
 fastlife/views/__init__.py,sha256=nn4B_8YTbTmhGPvSd20yyKK_9Dh1Pfh_Iq7z6iK8-CE,154
-fastlife/views/pydantic_form.py,sha256=4Et5oJ1dFiQlUY1msJA85aHZG5ngZPPdzaZ77W1Py8I,835
-fastlifeweb-0.2.0.dist-info/LICENSE,sha256=F75xSseSKMwqzFj8rswYU6NWS3VoWOc_gY3fJYf9_LI,1504
-fastlifeweb-0.2.0.dist-info/METADATA,sha256=qQ5ySuy9Lfhd06rarLgVNDz-O5CuWQiq3vndAanG7ZE,1471
-fastlifeweb-0.2.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-fastlifeweb-0.2.0.dist-info/RECORD,,
+fastlife/views/pydantic_form.py,sha256=5fBmw94wYLKuEN-YwqTnCLDDCq-TEzeJNmzWdsB2I3M,887
+fastlifeweb-0.2.2.dist-info/LICENSE,sha256=F75xSseSKMwqzFj8rswYU6NWS3VoWOc_gY3fJYf9_LI,1504
+fastlifeweb-0.2.2.dist-info/METADATA,sha256=AU7ZtKIfvQIFIaqSJhU5D4Fk5jzo4M-L2Kf5VGpTJBc,1750
+fastlifeweb-0.2.2.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+fastlifeweb-0.2.2.dist-info/RECORD,,