fastlifeweb 0.16.3__py3-none-any.whl → 0.17.0__py3-none-any.whl

fastlife/config/resources.py

@@ -8,7 +8,8 @@ API Resources declaration using a decorator.
 
 """
 
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 import venusian
 from fastapi.types import IncEx
@@ -54,7 +55,7 @@ def resource(
 
     Note that there is no abstract class that declare this method, this is done by
     introspection while returning the configuration method
-    {meth}`fastlife.config.configurator.Configurator.include`
+    {meth}`fastlife.config.configurator.GenericConfigurator.include`
     """
     tag = name
 
@@ -67,7 +68,7 @@ def resource(
 
             config: Configurator = getattr(scanner, VENUSIAN_CATEGORY)
             if description:
-                config.add_open_tag(
+                config.add_openapi_tag(
                     OpenApiTag(
                         name=tag, description=description, externalDocs=external_docs
                     )
@@ -91,29 +92,21 @@ def resource(
                     endpoint=endpoint,
                     tags=[tag],
                     methods=[method.split("_").pop()],
-                    permission=getattr(endpoint, "permission"),
-                    status_code=getattr(endpoint, "status_code"),
-                    summary=getattr(endpoint, "summary"),
-                    description=getattr(endpoint, "description"),
-                    response_description=getattr(endpoint, "response_description"),
-                    deprecated=getattr(endpoint, "deprecated"),
-                    operation_id=getattr(endpoint, "operation_id"),
-                    response_model_include=getattr(endpoint, "response_model_include"),
-                    response_model_exclude=getattr(endpoint, "response_model_exclude"),
-                    response_model_by_alias=getattr(
-                        endpoint, "response_model_by_alias"
-                    ),
-                    response_model_exclude_unset=getattr(
-                        endpoint, "response_model_exclude_unset"
-                    ),
-                    response_model_exclude_defaults=getattr(
-                        endpoint, "response_model_exclude_defaults"
-                    ),
-                    response_model_exclude_none=getattr(
-                        endpoint, "response_model_exclude_none"
-                    ),
-                    include_in_schema=getattr(endpoint, "include_in_schema"),
-                    openapi_extra=getattr(endpoint, "openapi_extra"),
+                    permission=endpoint.permission,
+                    status_code=endpoint.status_code,
+                    summary=endpoint.summary,
+                    description=endpoint.description,
+                    response_description=endpoint.response_description,
+                    deprecated=endpoint.deprecated,
+                    operation_id=endpoint.operation_id,
+                    response_model_include=endpoint.response_model_include,
+                    response_model_exclude=endpoint.response_model_exclude,
+                    response_model_by_alias=endpoint.response_model_by_alias,
+                    response_model_exclude_unset=endpoint.response_model_exclude_unset,
+                    response_model_exclude_defaults=endpoint.response_model_exclude_defaults,
+                    response_model_exclude_none=endpoint.response_model_exclude_none,
+                    include_in_schema=endpoint.include_in_schema,
+                    openapi_extra=endpoint.openapi_extra,
                 )
 
             for method in dir(ob):
@@ -131,7 +124,13 @@ def resource(
                             config, method, collection_path, getattr(api, method)
                         )
                     case (
-                        "get" | "post" | "put" | "patch" | "delete" | "head" | "options"
+                        "get"
+                        | "post"
+                        | "put"
+                        | "patch"
+                        | "delete"
+                        | "head"
+                        | "options"
                     ):
                         bind_config(config, method, path, getattr(api, method))
                     case _:

fastlife/config/settings.py

@@ -74,6 +74,8 @@ class Settings(BaseSettings):
     )
     """
     Set global constants accessible in every templates.
+    Defaults to `fastlife.templates.constants:Constants`
+    See {class}`fastlife.templates.constants.Constants`
     """
 
     session_secret_key: str = Field(default="")

fastlife/config/views.py

@@ -17,7 +17,9 @@ async def hello_world(
     return template()
 ```
 """
-from typing import Any, Callable
+
+from collections.abc import Callable
+from typing import Any
 
 import venusian
 

fastlife/middlewares/reverse_proxy/x_forwarded.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Optional, Sequence, Tuple
+from collections.abc import Sequence
 
 from starlette.types import ASGIApp, Receive, Scope, Send
 
@@ -8,21 +8,20 @@ from fastlife.middlewares.base import AbstractMiddleware
 log = logging.getLogger(__name__)
 
 
-def get_header(headers: Sequence[Tuple[bytes, bytes]], key: bytes) -> Optional[str]:
-    for hdr in headers:
-        if hdr[0].lower() == key:
-            return hdr[1].decode("latin1")
+def get_header(headers: Sequence[tuple[bytes, bytes]], key: bytes) -> str | None:
+    for hkey, val in headers:
+        if hkey.lower() == key:
+            return val.decode("latin1")
     return None
 
 
-def get_header_int(headers: Sequence[Tuple[bytes, bytes]], key: bytes) -> Optional[int]:
-    for hdr in headers:
-        if hdr[0].lower() == key:
-            ret = hdr[1].decode("latin1")
+def get_header_int(headers: Sequence[tuple[bytes, bytes]], key: bytes) -> int | None:
+    for hkey, val in headers:
+        if hkey.lower() == key:
             try:
-                return int(ret)
+                return int(val.decode("latin1"))
             except ValueError:
-                pass
+                break
     return None
 
 
@@ -36,11 +35,19 @@ class XForwardedStar(AbstractMiddleware):
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
         if scope["type"] in ("http", "websocket"):
             headers = scope["headers"]
+            x_real_ip = get_header(headers, b"x-real-ip")
+            client = (
+                (
+                    x_real_ip,
+                    get_header_int(headers, b"x-real-port")
+                    or get_header_int(headers, b"x-forwarded-port")
+                    or 0,
+                )
+                if x_real_ip
+                else None
+            )
             new_vals = {
-                "client": (
-                    get_header(headers, b"x-real-ip"),
-                    get_header_int(headers, b"x-forwarded-port"),
-                ),
+                "client": client,
                 "host": get_header(headers, b"x-forwarded-host"),
                 "scheme": get_header(headers, b"x-forwarded-proto"),
             }

fastlife/middlewares/session/middleware.py

@@ -1,7 +1,7 @@
 """Deal with http session."""
 
 from datetime import timedelta
-from typing import Literal, Type
+from typing import Literal
 
 from starlette.datastructures import MutableHeaders
 from starlette.requests import HTTPConnection
@@ -25,7 +25,7 @@ class SessionMiddleware(AbstractMiddleware):
         cookie_same_site: Literal["lax", "strict", "none"] = "lax",
         cookie_secure: bool = False,
         cookie_domain: str = "",
-        serializer: Type[AbsractSessionSerializer] = SignedSessionSerializer,
+        serializer: type[AbsractSessionSerializer] = SignedSessionSerializer,
     ) -> None:
         self.app = app
         self.max_age = int(duration.total_seconds())

fastlife/middlewares/session/serializer.py

@@ -1,8 +1,10 @@
 """Serialize session."""
+
 import abc
 import json
 from base64 import b64decode, b64encode
-from typing import Any, Mapping, Tuple
+from collections.abc import Mapping
+from typing import Any
 
 import itsdangerous
 
@@ -11,8 +13,7 @@ class AbsractSessionSerializer(abc.ABC):
     """Session serializer base class"""
 
     @abc.abstractmethod
-    def __init__(self, secret_key: str, max_age: int) -> None:
-        ...
+    def __init__(self, secret_key: str, max_age: int) -> None: ...
 
     @abc.abstractmethod
     def serialize(self, data: Mapping[str, Any]) -> bytes:
@@ -20,7 +21,7 @@ class AbsractSessionSerializer(abc.ABC):
         ...
 
     @abc.abstractmethod
-    def deserialize(self, data: bytes) -> Tuple[Mapping[str, Any], bool]:
+    def deserialize(self, data: bytes) -> tuple[Mapping[str, Any], bool]:
         """Derialize the session raw bytes content and return it as a mapping."""
         ...
 
@@ -47,7 +48,7 @@ class SignedSessionSerializer(AbsractSessionSerializer):
         signed = self.signer.sign(encoded)
         return signed
 
-    def deserialize(self, data: bytes) -> Tuple[Mapping[str, Any], bool]:
+    def deserialize(self, data: bytes) -> tuple[Mapping[str, Any], bool]:
         """Deserialize the session.
 
         If the signature is incorect, the session restart from the begining.

fastlife/request/form.py

@@ -1,6 +1,7 @@
 """HTTP Form serialization."""
 
-from typing import Any, Callable, Generic, Mapping, Type, TypeVar, get_origin
+from collections.abc import Callable, Mapping
+from typing import Any, Generic, TypeVar, get_origin
 
 from fastapi import Depends
 from pydantic import BaseModel, ValidationError
@@ -28,7 +29,7 @@ class FormModel(Generic[T]):
         self.is_valid = is_valid
 
     @classmethod
-    def default(cls, prefix: str, pydantic_type: Type[T]) -> "FormModel[T]":
+    def default(cls, prefix: str, pydantic_type: type[T]) -> "FormModel[T]":
         return cls(prefix, pydantic_type.model_construct(), {})
 
     def edit(self, pydantic_type: T) -> None:
@@ -47,7 +48,7 @@ class FormModel(Generic[T]):
 
     @classmethod
     def from_payload(
-        cls, prefix: str, pydantic_type: Type[T], data: Mapping[str, Any]
+        cls, prefix: str, pydantic_type: type[T], data: Mapping[str, Any]
     ) -> "FormModel[T]":
         try:
             return cls(prefix, pydantic_type(**data.get(prefix, {})), {}, True)
@@ -68,12 +69,12 @@ class FormModel(Generic[T]):
                                         continue
 
                             else:
-                                raise NotImplementedError
+                                raise NotImplementedError from exc  # coverage: ignore
                         elif issubclass(typ, BaseModel):
                             typ = typ.model_fields[part].annotation
                             loc = f"{loc}.{part}"
                         else:
-                            raise NotImplementedError
+                            raise NotImplementedError from exc  # coverage: ignore
 
                     else:
                         # it is an integer and it part of the list
@@ -88,7 +89,7 @@ class FormModel(Generic[T]):
 
 
 def form_model(
-    cls: Type[T], name: str | None = None
+    cls: type[T], name: str | None = None
 ) -> Callable[[Mapping[str, Any]], FormModel[T]]:
     """
     Build a model, a class of type T based on Pydandic Base Model from a form payload.

fastlife/request/form_data.py

@@ -2,14 +2,10 @@
 Set of functions to unserialize www-form-urlencoded format to python simple types.
 """
 
+from collections.abc import Mapping, MutableMapping, MutableSequence, Sequence
 from typing import (
     Annotated,
     Any,
-    Mapping,
-    MutableMapping,
-    MutableSequence,
-    Optional,
-    Sequence,
 )
 
 from fastapi import Depends
@@ -22,7 +18,7 @@ def unflatten_struct(
     unflattened_output: MutableMapping[str, Any] | MutableSequence[Any],
     level: int = 0,
     *,
-    csrf_token_name: Optional[str] = None,
+    csrf_token_name: str | None = None,
 ) -> Mapping[str, Any] | Sequence[Any]:
     """
     Take a flatten_input map, with key segmented by `.` and build a nested dict.

fastlife/routing/route.py

@@ -1,5 +1,7 @@
 """HTTP Route."""
-from typing import TYPE_CHECKING, Any, Callable, Coroutine
+
+from collections.abc import Callable, Coroutine
+from typing import TYPE_CHECKING, Any
 
 from fastapi.routing import APIRoute
 from starlette.requests import Request as StarletteRequest

fastlife/routing/router.py

@@ -4,6 +4,7 @@ FastApi router for fastlife application.
 The aim of this router is get {class}`fastlife.routing.route.Route`
 available in the FastApi request depency injection.
 """
+
 from typing import Any
 
 from fastapi import APIRouter

fastlife/security/csrf.py

@@ -19,7 +19,8 @@ no way to prevent to set the cookie in the request.
 """
 
 import secrets
-from typing import Any, Callable, Coroutine
+from collections.abc import Callable, Coroutine
+from typing import Any
 
 from fastlife.request import Request
 

fastlife/security/policy.py

@@ -2,7 +2,8 @@
 
 import abc
 import logging
-from typing import Annotated, Any, Callable, Coroutine, Generic, Literal, TypeVar
+from collections.abc import Callable, Coroutine
+from typing import Annotated, Any, Generic, Literal, TypeVar
 from uuid import UUID
 
 from fastapi import Depends, HTTPException

fastlife/services/locale_negociator.py

@@ -1,6 +1,7 @@
 """Find the localization gor the given request."""
 
-from typing import TYPE_CHECKING, Any, Callable
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
 
 from fastlife.config.settings import Settings
 

fastlife/services/policy.py

@@ -1,6 +1,7 @@
 """Security policy."""
 
-from typing import Any, Callable, Coroutine
+from collections.abc import Callable, Coroutine
+from typing import Any
 
 CheckPermissionHook = Callable[..., Coroutine[Any, Any, None]] | Callable[..., None]
 CheckPermission = Callable[[str], CheckPermissionHook]
@@ -12,7 +13,7 @@ def check_permission(permission_name: str) -> CheckPermissionHook:
 
     Adding a permission on the route requires that a security policy has been
     added using the method
-    {meth}`fastlife.config.configurator.Configurator.set_security_policy`
+    {meth}`fastlife.config.configurator.GenericConfigurator.set_security_policy`
 
     :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.

fastlife/services/templates.py

@@ -10,7 +10,8 @@ In that case, those base classes have to be implemented.
 """
 
 import abc
-from typing import Any, Callable, Mapping
+from collections.abc import Callable, Mapping
+from typing import Any
 
 from fastlife import Request, Response
 from fastlife.security.csrf import create_csrf_token

fastlife/services/translations.py

@@ -1,5 +1,6 @@
 import pathlib
-from typing import TYPE_CHECKING, Iterator, Tuple
+from collections.abc import Iterator
+from typing import TYPE_CHECKING
 
 from babel.support import NullTranslations, Translations
 
@@ -11,16 +12,22 @@ if TYPE_CHECKING:
 locale_name = str
 
 
-def find_mo_files(root_path: str) -> Iterator[Tuple[str, str, pathlib.Path]]:
+def find_mo_files(root_path: str) -> Iterator[tuple[str, str, pathlib.Path]]:
+    """
+    Find .mo files in a locales directory.
+
+    :param root_path: locales directory.
+    :return: a tupple containing locale_name, domain, file.
+    """
     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
+        lc_messages_dir = locale_dir / "LC_MESSAGES"
+        if not (locale_dir.is_dir() and lc_messages_dir.is_dir()):
+            continue
+
+        for mo_file in lc_messages_dir.glob("*.mo"):
+            yield locale_dir.name, mo_file.stem, mo_file
 
 
 class Localizer:

fastlife/shared_utils/infer.py

@@ -1,11 +1,12 @@
 """Type inference."""
+
 from types import UnionType
-from typing import Any, Type, Union, get_origin
+from typing import Any, Union, get_origin
 
 from pydantic import BaseModel
 
 
-def is_complex_type(typ: Type[Any]) -> bool:
+def is_complex_type(typ: type[Any]) -> bool:
     """
     Used to detect complex type such as Mapping, Sequence and pydantic BaseModel.
 
@@ -14,7 +15,7 @@ def is_complex_type(typ: Type[Any]) -> bool:
     return bool(get_origin(typ) or issubclass(typ, BaseModel))
 
 
-def is_union(typ: Type[Any]) -> bool:
+def is_union(typ: type[Any]) -> bool:
     """Used to detect unions like Optional[T], Union[T, U] or T | U."""
     type_origin = get_origin(typ)
     if type_origin:

fastlife/shared_utils/resolver.py

@@ -1,7 +1,9 @@
 """Resolution of python objects for dependency injection and more."""
+
 import importlib.util
+import inspect
 from pathlib import Path
-from types import UnionType
+from types import ModuleType, UnionType
 from typing import Any, Union
 
 
@@ -20,8 +22,10 @@ def resolve(value: str) -> Any:
 
     try:
         attr = getattr(module, attr_name)
-    except AttributeError:
-        raise ValueError(f"Attribute {attr_name} not found in module {module_name}")
+    except AttributeError as exc:
+        raise ValueError(
+            f"Attribute {attr_name} not found in module {module_name}"
+        ) from exc
 
     return attr
 
@@ -32,7 +36,7 @@ def resolve_extended(value: str) -> UnionType:
     if len(values) == 1:
         return resolve(value)
     types = [resolve(t) for t in values if t != "builtins:NoneType"]
-    return Union[tuple(types)]  # type: ignore
+    return Union[tuple(types)]  # type: ignore # noqa: UP007
 
 
 def resolve_path(value: str) -> str:
@@ -48,3 +52,59 @@ def resolve_path(value: str) -> str:
     package_path = spec.origin
     full_path = Path(package_path).parent / resource_name
     return str(full_path)
+
+
+def resolve_package(mod: ModuleType) -> ModuleType:
+    """
+    Return the
+    [regular package](https://docs.python.org/3/glossary.html#term-regular-package)
+    of a module or itself if it is the ini file of a package.
+
+    """
+
+    # Compiled package has no __file__ attribute, ModuleType declare it as NoneType
+    if not hasattr(mod, "__file__") or mod.__file__ is None:
+        return mod
+
+    module_path = Path(mod.__file__)
+    if module_path.name == "__init__.py":
+        return mod
+
+    parent_module_name = mod.__name__.rsplit(".", 1)[0]
+    parent_module = importlib.import_module(parent_module_name)
+    return parent_module
+
+
+def _strip_left_dots(s: str) -> tuple[str, int]:
+    stripped_string = s.lstrip(".")
+    num_stripped_dots = len(s) - len(stripped_string)
+    return stripped_string, num_stripped_dots - 1
+
+
+def _get_parent(pkg: str, num_parents: int) -> str:
+    if num_parents == 0:
+        return pkg
+    segments = pkg.split(".")
+    return ".".join(segments[:-num_parents])
+
+
+def resolve_maybe_relative(mod: str, stack_depth: int = 1) -> ModuleType:
+    """
+    Resolve a module, maybe relative to the stack frame and import it.
+
+    :param mod: the module to import. starts with a dot if it is relative.
+    :param stack_depth: relative to which module in the stack.
+        used to do an api that call it instead of resolve the module directly.
+    :return: the imported module
+    """
+    if mod.startswith("."):
+        caller_module = inspect.getmodule(inspect.stack()[stack_depth][0])
+        # we could do an assert here but caller_module could really be none ?
+        parent_module = resolve_package(caller_module)  # type: ignore
+        package = parent_module.__name__
+        mod, count = _strip_left_dots(mod)
+        package = _get_parent(package, count)
+        mod = f"{package}.{mod}".rstrip(".")
+
+    module = importlib.import_module(mod)
+    return module

fastlife/templates/binding.py

@@ -2,7 +2,8 @@
 Bind template to the view in order to build an html response.
 """
 
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 from fastapi import Depends, Response
 

fastlife/testing/__init__.py

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