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

fastlife/{templating/renderer/abstract.py → services/templates.py}

@@ -1,21 +1,21 @@
 """
 Base class to of the template renderer.
 
-Fastlife comes with :class:`fastlife.templating.renderer.jinjax.JinjaxTemplateRenderer`,
+Fastlife comes with {class}`fastlife.templating.renderer.jinjax.JinjaxTemplateRenderer`,
 the rendering engine, it can be overriden from the setting
 :attr:`fastlife.config.settings.Settings.template_renderer_class`.
 
 In that case, those base classes have to be implemented.
 
 """
+
 import abc
-from typing import Any, Mapping, Optional, Type
+from typing import Any, Callable, Mapping
 
-from fastapi import Request
-from markupsafe import Markup
-from pydantic.fields import FieldInfo
+from fastlife import Request, Response
+from fastlife.security.csrf import create_csrf_token
 
-from fastlife.request.form import FormModel
+TemplateParams = Mapping[str, Any]
 
 
 class AbstractTemplateRenderer(abc.ABC):
@@ -24,15 +24,54 @@ class AbstractTemplateRenderer(abc.ABC):
     passing the request to process.
     """
 
-    route_prefix: str
-    """Used to buid pydantic form."""
+    request: Request
+    """Associated request that needs a response."""
+
+    def __init__(self, request: Request) -> None:
+        self.request = request
+
+    @property
+    def route_prefix(self) -> str:
+        """Used to buid pydantic form widget that do ajax requests."""
+        return self.request.registry.settings.fastlife_route_prefix
+
+    def render(
+        self,
+        template: str,
+        *,
+        status_code: int = 200,
+        content_type: str = "text/html",
+        globals: Mapping[str, Any] | None = None,
+        params: TemplateParams,
+        _create_csrf_token: Callable[..., str] = create_csrf_token,
+    ) -> Response:
+        """
+        Render the template and build the HTTP Response.
+        """
+        request = self.request
+        reg = request.registry
+        request.scope[reg.settings.csrf_token_name] = (
+            request.cookies.get(reg.settings.csrf_token_name) or _create_csrf_token()
+        )
+        data = self.render_template(template, **params)
+        resp = Response(
+            data, status_code=status_code, headers={"Content-Type": content_type}
+        )
+        resp.set_cookie(
+            reg.settings.csrf_token_name,
+            request.scope[reg.settings.csrf_token_name],
+            secure=request.url.scheme == "https",
+            samesite="strict",
+            max_age=60 * 15,
+        )
+        return resp
 
     @abc.abstractmethod
     def render_template(
         self,
         template: str,
         *,
-        globals: Optional[Mapping[str, Any]] = None,
+        globals: Mapping[str, Any] | None = None,
         **params: Any,
     ) -> str:
         """
@@ -54,52 +93,6 @@ class AbstractTemplateRenderer(abc.ABC):
         :return: The template rendering result.
         """
 
-    @abc.abstractmethod
-    def pydantic_form(
-        self, model: FormModel[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):
     """

fastlife/services/translations.py

@@ -0,0 +1,131 @@
+import pathlib
+from typing import TYPE_CHECKING, Iterator, Tuple
+
+from babel.support import NullTranslations, Translations
+
+from fastlife.shared_utils.resolver import resolve_path
+
+if TYPE_CHECKING:
+    from fastlife import Request  # coverage: ignore
+
+locale_name = str
+
+
+def find_mo_files(root_path: str) -> Iterator[Tuple[str, str, pathlib.Path]]:
+    root = pathlib.Path(root_path)
+
+    # Walk through the directory structure and match the pattern
+    for locale_dir in root.iterdir():
+        if locale_dir.is_dir():  # Ensure it's a directory (locale)
+            lc_messages_dir = locale_dir / "LC_MESSAGES"
+            if lc_messages_dir.exists() and lc_messages_dir.is_dir():
+                for mo_file in lc_messages_dir.glob("*.mo"):  # Find .mo files
+                    yield locale_dir.name, mo_file.name[:-3], mo_file
+
+
+class Localizer:
+    def __init__(
+        self, request: "Request", translations: Translations | NullTranslations
+    ) -> None:
+        self.locale_name = request.locale_name
+        self.translations = translations
+
+    def gettext(self, message: str, mapping: dict[str, str] | None = None) -> str:
+        ret = self.translations.gettext(message)
+        if mapping is not None:
+            ret = ret.format(**mapping)
+        return ret
+
+    def ngettext(
+        self, singular: str, plural: str, n: int, mapping: dict[str, str] | None = None
+    ) -> str:
+        ret = self.translations.ngettext(singular, plural, n)
+        mapping_num = {"num": n, **(mapping or {})}
+        return ret.format(**mapping_num)
+
+    def dgettext(
+        self, domain: str, message: str, mapping: dict[str, str] | None = None
+    ) -> str:
+        ret = self.translations.dgettext(domain, message)
+        if mapping:
+            ret = ret.format(**mapping)
+        return ret
+
+    def dngettext(
+        self,
+        domain: str,
+        singular: str,
+        plural: str,
+        n: int,
+        mapping: dict[str, str] | None = None,
+    ) -> str:
+        ret = self.translations.dngettext(domain, singular, plural, n)
+        mapping_num = {"num": n, **(mapping or {})}
+        return ret.format(**mapping_num)
+
+    def pgettext(
+        self, context: str, message: str, mapping: dict[str, str] | None = None
+    ) -> str:
+        ret = str(self.translations.pgettext(context, message))
+        if mapping:
+            ret = ret.format(**mapping)
+        return ret
+
+    def dpgettext(
+        self,
+        domain: str,
+        context: str,
+        message: str,
+        mapping: dict[str, str] | None = None,
+    ) -> str:
+        ret = str(self.translations.dpgettext(domain, context, message))
+        if mapping:
+            ret = ret.format(**mapping)
+        return ret
+
+    def dnpgettext(
+        self,
+        domain: str,
+        context: str,
+        singular: str,
+        plural: str,
+        n: int,
+        mapping: dict[str, str] | None = None,
+    ) -> str:
+        ret = self.translations.dnpgettext(domain, context, singular, plural, n)
+        mapping_num = {"num": n, **(mapping or {})}
+        return ret.format(**mapping_num)
+
+
+class LocalizerFactory:
+    """Initialize the proper translation context per request."""
+
+    _translations: dict[locale_name, Translations]
+
+    def __init__(self) -> None:
+        self._translations = {}
+
+    def load(self, path: str) -> None:
+        """
+        load a translations from the model.
+        :param path: a python module and the locales dir separated by a `:`
+        """
+        root_path = resolve_path(path)
+        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
+
+    def __call__(self, request: "Request") -> Localizer:
+        """Create the translation context for the given request."""
+        trans: Translations | NullTranslations | None = self._translations.get(
+            request.locale_name
+        )
+        if not trans:
+            trans = self._translations.get(request.registry.settings.default_locale)
+        if not trans:
+            trans = NullTranslations()
+        return Localizer(request, trans)

fastlife/templates/__init__.py

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

fastlife/{templating → templates}/binding.py

@@ -31,20 +31,9 @@ def get_template(template: str, *, content_type: str = "text/html") -> TemplateE
         reg = request.registry
 
         def parametrizer(**kwargs: Any) -> Response:
-            request.scope[reg.settings.csrf_token_name] = (
-                request.cookies.get(reg.settings.csrf_token_name)
-                or _create_csrf_token()
+            return reg.get_renderer(template)(request).render(
+                template, content_type=content_type, params=kwargs
             )
-            data = reg.renderer(request).render_template(template, **kwargs)
-            resp = Response(data, headers={"Content-Type": content_type})
-            resp.set_cookie(
-                reg.settings.csrf_token_name,
-                request.scope[reg.settings.csrf_token_name],
-                secure=request.url.scheme == "https",
-                samesite="strict",
-                max_age=60 * 15,
-            )
-            return resp
 
         return parametrizer
 

fastlife/views/pydantic_form.py

@@ -1,9 +1,10 @@
-from typing import Optional
+from typing import Optional, cast
 
-from fastapi import Query, Request, Response
+from fastapi import Query
 from pydantic.fields import FieldInfo
 
-from fastlife import Configurator, configure
+from fastlife import Configurator, Request, Response, configure
+from fastlife.adapters.jinjax.renderer import JinjaxRenderer
 from fastlife.config.registry import Registry
 from fastlife.shared_utils.resolver import resolve_extended
 
@@ -24,7 +25,9 @@ async def show_widget(
     field = None
     if title:
         field = FieldInfo(title=title)
-    data = reg.renderer(request).pydantic_form_field(
+    # FIXME: .jinja should not be hardcoded
+    renderer = cast(JinjaxRenderer, reg.get_renderer(".jinja")(request))
+    data = renderer.pydantic_form_field(
         model=model_cls,  # type: ignore
         name=name,
         token=token,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastlifeweb
-Version: 0.11.1
+Version: 0.13.0
 Summary: High-level web framework
 Home-page: https://github.com/mardiros/fastlife
 License: BSD-derived
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: babel (>=2.16.0,<3.0.0)
 Requires-Dist: beautifulsoup4[testing] (>=4.12.2,<5.0.0)
 Requires-Dist: fastapi[standard] (>=0.115.0,<0.116.0)
 Requires-Dist: itsdangerous (>=2.1.2,<3.0.0)
@@ -36,12 +37,49 @@ Description-Content-Type: text/markdown
 [![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**
+> Please note that this project is still in active development. Features and APIs may change frequently.
+> Even the name is not definitive.
 
-Under heavy development.
+An opinionated framework Python web framework (based on FastAPI).
+
+## Purpose
+
+Fastlife helps at building Web Application with html form generated from pydantic schema
+using customizable widget.
+
+Templates are made using [JinjaX](https://jinjax.scaletti.dev/) and an extensible [set of
+component](https://mardiros.github.io/fastlife/components/index.html) is available
+in order to build pages.
+
+Those components are currently stylized by [tailwindcss](https://tailwindcss.com/),
+using [pytailwindcss](https://github.com/timonweb/pytailwindcss).
+
+Moreover, you can also write API, in an opinionated way to enforce documentation
+consistency.
+
+
+## First class configuration.
+
+Fastlife is adding a "Configurator", like Pyramid to get a better scallable codebase.
+
+The configurator in fastlife organizes configuration settings hierarchically,
+enabling easy management and overriding at different levels.
+This promotes modularity and clarity in application configuration, making it simpler
+to maintain and scale your project.
+
+
+## Tests
+
+Fastlife come with [a test client](https://mardiros.github.io/fastlife/develop/fastlife/fastlife.testing.testclient.html) that can interact with html inside unit tests.
+
+
+## Try it
 
 The package is available on pypi with the name fastlifeweb.
 
+```bash
+pip install fastlifeweb
+```
+