fastapi-factory-utilities 0.2.12__tar.gz → 0.3.1__tar.gz

{fastapi_factory_utilities-0.2.12 → fastapi_factory_utilities-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fastapi_factory_utilities
-Version: 0.2.12
+Version: 0.3.1
 Summary: Consolidate libraries and utilities to create microservices in Python with FastAPI, Beanie, Httpx, AioPika and OpenTelemetry.
 License: MIT
 Keywords: python,fastapi,beanie,httpx,opentelemetry,microservices
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: aiohttp[speedups] (>=3.11.16,<4.0.0)
 Requires-Dist: beanie (>=1.27.0,<2.0.0)
 Requires-Dist: fastapi (>=0.115.4,<0.116.0)
 Requires-Dist: httpx (>=0.28.1,<0.29.0)
@@ -29,6 +30,7 @@ Requires-Dist: opentelemetry-propagator-b3 (>=1.26.0,<2.0.0)
 Requires-Dist: opentelemetry-sdk (>=1.26.0,<2.0.0)
 Requires-Dist: pyaml (>=25.1.0,<26.0.0)
 Requires-Dist: pydantic (>=2.8.2,<3.0.0)
+Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
 Requires-Dist: pymongo (>=4.9.2,<4.10.0)
 Requires-Dist: reactivex (>=4.0.4,<5.0.0)
 Requires-Dist: structlog (>=24.1,<26.0)

{fastapi_factory_utilities-0.2.12 → fastapi_factory_utilities-0.3.1}/pyproject.toml

@@ -3,7 +3,7 @@ name = "fastapi_factory_utilities"
 homepage = "https://github.com/miragecentury/fastapi_factory_utilities"
 repository = "https://github.com/miragecentury/fastapi_factory_utilities"
 keywords = ["python", "fastapi", "beanie", "httpx", "opentelemetry", "microservices"]
-version = "0.2.12"
+version = "0.3.1"
 description = "Consolidate libraries and utilities to create microservices in Python with FastAPI, Beanie, Httpx, AioPika and OpenTelemetry."
 authors = ["miragecentury <victorien.vanroye@gmail.com>"]
 maintainers = ["miragecentury <victorien.vanroye@gmail.com>"]
@@ -42,6 +42,8 @@ opentelemetry-instrumentation-pymongo = "^0.49b2"
 pymongo = "~4.9.2" # version fixed to fix integration between beanie and pytest-mongo
 pyaml = "^25.1.0"
 reactivex = "^4.0.4"
+pyjwt = "^2.10.1"
+aiohttp = { version="^3.11.16", extras=["speedups"] }
 
 [tool.poetry.group.test]
 optional = true

{fastapi_factory_utilities-0.2.12 → fastapi_factory_utilities-0.3.1}/src/fastapi_factory_utilities/core/app/__init__.py

@@ -2,7 +2,13 @@
 
 from .application import ApplicationAbstract
 from .builder import ApplicationGenericBuilder
-from .config import BaseApplicationConfig, RootConfig
+from .config import (
+    BaseApplicationConfig,
+    DependencyConfig,
+    HttpServiceDependencyConfig,
+    RootConfig,
+    depends_dependency_config,
+)
 from .enums import EnvironmentEnum
 
 __all__: list[str] = [
@@ -11,4 +17,7 @@ __all__: list[str] = [
     "ApplicationAbstract",
     "ApplicationGenericBuilder",
     "RootConfig",
+    "HttpServiceDependencyConfig",
+    "DependencyConfig",
+    "depends_dependency_config",
 ]

{fastapi_factory_utilities-0.2.12 → fastapi_factory_utilities-0.3.1}/src/fastapi_factory_utilities/core/app/config.py

@@ -2,7 +2,8 @@
 
 from typing import Any, ClassVar, Generic, TypeVar, get_args
 
-from pydantic import BaseModel, ConfigDict, Field
+from fastapi import Request
+from pydantic import BaseModel, ConfigDict, Field, HttpUrl
 
 from fastapi_factory_utilities.core.app.exceptions import ConfigBuilderError
 from fastapi_factory_utilities.core.utils.configs import (
@@ -71,6 +72,18 @@ class BaseApplicationConfig(BaseModel):
     root_path: str = Field(default="", description="Root path")
 
 
+class HttpServiceDependencyConfig(BaseModel):
+    """Http service dependency config."""
+
+    url: HttpUrl
+
+
+class DependencyConfig(BaseModel):
+    """Dependency config."""
+
+    kratos: HttpServiceDependencyConfig | None = Field(default=None, description="Kratos dependency config")
+
+
 class RootConfig(BaseModel):
     """Root configuration."""
 
@@ -84,6 +97,7 @@ class RootConfig(BaseModel):
     cors: CorsConfig = Field(description="CORS configuration", default_factory=CorsConfig)
     development: DevelopmentConfig = Field(description="Development configuration", default_factory=DevelopmentConfig)
     logging: list[LoggingConfig] = Field(description="Logging configuration", default_factory=list)
+    dependencies: DependencyConfig = Field(description="Dependencies configuration", default_factory=DependencyConfig)
 
 
 GenericConfig = TypeVar("GenericConfig", bound=BaseModel)
@@ -162,3 +176,8 @@ class GenericConfigBuilder(Generic[GenericConfig]):
             ) from exception
 
         return config
+
+
+def depends_dependency_config(request: Request) -> DependencyConfig:
+    """Get the dependency config."""
+    return request.app.state.config.dependencies

{fastapi_factory_utilities-0.2.12 → fastapi_factory_utilities-0.3.1}/src/fastapi_factory_utilities/core/plugins/odm_plugin/repositories.py

@@ -4,9 +4,22 @@ import datetime
 from abc import ABC
 from collections.abc import AsyncGenerator, Callable
 from contextlib import asynccontextmanager
-from typing import Any, Generic, TypeVar, get_args
+from typing import (
+    Any,
+    Dict,
+    Generic,
+    List,
+    Mapping,
+    Optional,
+    Tuple,
+    TypeVar,
+    Union,
+    get_args,
+)
 from uuid import UUID
 
+from beanie import SortDirection
+from beanie.odm.queries.find import FindMany
 from motor.motor_asyncio import AsyncIOMotorClientSession, AsyncIOMotorDatabase
 from pydantic import BaseModel
 from pymongo.errors import DuplicateKeyError, PyMongoError
@@ -214,3 +227,66 @@ class AbstractRepository(ABC, Generic[DocumentGenericType, EntityGenericType]):
             return
 
         raise OperationError("Failed to delete document.")
+
+    @managed_session()
+    async def find(
+        self,
+        *args: Union[Mapping[str, Any], bool],
+        projection_model: None = None,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        sort: Union[None, str, List[Tuple[str, SortDirection]]] = None,
+        session: Optional[AsyncIOMotorClientSession] = None,
+        ignore_cache: bool = False,
+        fetch_links: bool = False,
+        lazy_parse: bool = False,
+        nesting_depth: Optional[int] = None,
+        nesting_depths_per_field: Optional[Dict[str, int]] = None,
+        **pymongo_kwargs: Any,
+    ) -> list[EntityGenericType]:
+        """Find documents in the database.
+
+        Args:
+            *args: The arguments to pass to the find method.
+            projection_model: The projection model to use.
+            skip: The number of documents to skip.
+            limit: The number of documents to return.
+            sort: The sort order.
+            session: The session to use.
+            ignore_cache: Whether to ignore the cache.
+            fetch_links: Whether to fetch links.
+            lazy_parse: Whether to lazy parse the documents.
+            nesting_depth: The nesting depth.
+            nesting_depths_per_field: The nesting depths per field.
+            **pymongo_kwargs: Additional keyword arguments to pass to the find method.
+
+        Returns:
+            list[EntityGenericType]: The list of entities.
+
+        Raises:
+            OperationError: If the operation fails.
+            ValueError: If the entity cannot be created from the document.
+        """
+        try:
+            documents: list[DocumentGenericType] = await self._document_type.find(
+                *args,
+                projection_model=projection_model,
+                skip=skip,
+                limit=limit,
+                sort=sort,
+                session=session,
+                ignore_cache=ignore_cache,
+                fetch_links=fetch_links,
+                lazy_parse=lazy_parse,
+                nesting_depth=nesting_depth,
+                nesting_depths_per_field=nesting_depths_per_field,
+            ).to_list()
+        except PyMongoError as error:
+            raise OperationError(f"Failed to find documents: {error}") from error
+
+        try:
+            entities: list[EntityGenericType] = [self._entity_type(**document.model_dump()) for document in documents]
+        except ValueError as error:
+            raise ValueError(f"Failed to create entity from document: {error}") from error
+
+        return entities

fastapi_factory_utilities-0.3.1/src/fastapi_factory_utilities/core/security/jwt.py

@@ -0,0 +1,158 @@
+"""Provides security-related functions for the API."""
+
+from asyncio import Task, TaskGroup
+from http import HTTPStatus
+from typing import Any, ClassVar, NewType, cast
+
+import jwt
+import pydantic
+from fastapi import Request
+from fastapi.exceptions import HTTPException
+from pydantic import BaseModel
+
+Scope = NewType("Scope", str)
+
+
+class JWTBearerDecoded(BaseModel):
+    """JWT bearer token decoded."""
+
+    model_config: ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(
+        arbitrary_types_allowed=True,
+        extra="forbid",
+        frozen=True,
+    )
+
+    scopes: list[str] | None = None
+
+
+class JWTBearerAuthentication:
+    """JWT Bearer Authentication.
+
+    This class is used to authenticate users using JWT tokens.
+    It extracts the token from the request, decodes it, and verifies its validity.
+    """
+
+    def __init__(self, scopes: list[Scope] | None = None, jwt_raw: str | None = None) -> None:
+        """Initialize the OAuth2 class.
+
+        Args:
+            scopes (SecurityScopes): Security scopes for the OAuth2.
+            jwt_raw (str): JWT token to be used for authentication.
+        """
+        self.jwt_raw: str | None = jwt_raw
+        self.scopes: list[Scope] | None = scopes
+
+    def _extract_raw_token(self, request: Request) -> str:
+        """Extract the raw token from the request.
+
+        Args:
+            request (Request): FastAPI request object.
+
+        Returns:
+            str: Raw token.
+
+        Raises:
+            HTTPException: If the token is missing or invalid.
+        """
+        try:
+            authorization_header: str | None = request.headers.get("Authorization")
+        except (AttributeError, KeyError) as e:
+            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="Missing Credentials") from e
+
+        if not authorization_header:
+            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="Missing Credentials")
+
+        if not authorization_header.startswith("Bearer "):
+            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="Invalid Credentials")
+
+        return authorization_header.split(sep=" ")[1]
+
+    async def _decode_jwt(self, jwt_raw: str) -> JWTBearerDecoded:
+        """Decode the JWT token.
+
+        Args:
+            jwt_raw (str): Raw JWT token.
+
+        Returns:
+            JWTBearerDecoded: Decoded JWT token.
+
+        Raises:
+            HTTPException: If the token is invalid or expired.
+        """
+        try:
+            jwt_decoded: dict[str, Any] = cast(
+                dict[str, Any],
+                jwt.decode(
+                    jwt=jwt_raw,
+                    algorithms=["HS256", "RS256"],
+                    options={"verify_signature": True},
+                ),
+            )
+            return JWTBearerDecoded(**jwt_decoded)
+        except jwt.ExpiredSignatureError as e:
+            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="Token expired") from e
+        except jwt.InvalidTokenError as e:
+            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="Invalid token") from e
+        except pydantic.ValidationError as e:
+            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail=f"Invalid token: {e.json()}") from e
+
+    async def _verify(self, jwt_raw: str) -> None:
+        """Verify the JWT token.
+
+        Args:
+            jwt_raw (str): Raw JWT token.
+        """
+        pass
+
+    def _has_scope(self, jwt_decoded: JWTBearerDecoded) -> None:
+        """Check if the JWT token has the required scope.
+
+        Args:
+            jwt_decoded (JWTBearerDecoded): Decoded JWT token.
+
+        """
+        # Just Authentication (no scopes, no authorization)
+        if not self.scopes:
+            return
+        # JWT without scopes (no authorization)
+        if not jwt_decoded.scopes:
+            raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="Unauthorized")
+        # Check if all required scopes are present
+        if not all(scope in jwt_decoded.scopes for scope in (self.scopes or [])):
+            raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="Unauthorized")
+
+        # All scopes are valid (authorization)
+        return
+
+    async def __call__(self, request: Request | None = None) -> JWTBearerDecoded:
+        """Call the JWT bearer authentication.
+
+        Args:
+            request (Request): FastAPI request object.
+
+        Returns:
+            JWTBearerDecoded: Decoded JWT token.
+
+        Raises:
+            HTTPException: If the token is missing or invalid.
+        """
+        # Ensure that the jwt will be provided
+        # by the request or by the jwt parameter
+        if self.jwt_raw is None and request is None:
+            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="Missing Credentials")
+        jwt_raw: str = (
+            self.jwt_raw
+            if self.jwt_raw is not None
+            else self._extract_raw_token(request=request)  # type: ignore[arg-type]
+        )
+        # Execute the io bound and cpu bound tasks in parallel
+        async with TaskGroup() as tg:
+            # TODO: Can be disabled by configuration (for operation purposes)
+            # Ensure that the jwt is not revoked or expired
+            tg.create_task(self._verify(jwt_raw=jwt_raw), name="verify_jwt")
+            # Ensure that the jwt is not altered or expired
+            task_decode: Task[Any] = tg.create_task(self._decode_jwt(jwt_raw=jwt_raw), name="decode_jwt")
+        # Scope Validation
+        jwt_decoded: JWTBearerDecoded = task_decode.result()
+        self._has_scope(jwt_decoded=jwt_decoded)
+        return jwt_decoded

fastapi_factory_utilities-0.3.1/src/fastapi_factory_utilities/core/security/kratos.py

@@ -0,0 +1,78 @@
+"""Provide Kratos Session and Identity classes."""
+
+from typing import Annotated
+
+from fastapi import Depends, HTTPException, Request
+
+from fastapi_factory_utilities.core.services.kratos import (
+    KratosOperationError,
+    KratosService,
+    KratosSessionInvalidError,
+    KratosSessionObject,
+    depends_kratos_service,
+)
+
+
+class KratosSessionAuthentication:
+    """Kratos Session class."""
+
+    DEFAULT_COOKIE_NAME: str = "ory_kratos_session"
+
+    def __init__(self, cookie_name: str = DEFAULT_COOKIE_NAME) -> None:
+        """Initialize the KratosSessionAuthentication class.
+
+        Args:
+            cookie_name (str): Name of the cookie to extract the session
+        """
+        self._cookie_name: str = cookie_name
+
+    def _extract_cookie(self, request: Request) -> str:
+        """Extract the cookie from the request.
+
+        Args:
+            request (Request): FastAPI request object.
+
+        Returns:
+            str | None: Cookie value or None if not found.
+
+        Raises:
+            HTTPException: If the cookie is missing.
+        """
+        cookie: str | None = request.cookies.get(self._cookie_name)
+        if not cookie:
+            raise HTTPException(
+                status_code=401,
+                detail="Missing Credentials",
+            )
+        return cookie
+
+    async def __call__(
+        self, request: Request, kratos_service: Annotated[KratosService, Depends(depends_kratos_service)]
+    ) -> KratosSessionObject:
+        """Extract the Kratos session from the request.
+
+        Args:
+            request (Request): FastAPI request object.
+            kratos_service (KratosService): Kratos service object.
+
+        Returns:
+            KratosSessionObject: Kratos session object.
+
+        Raises:
+            HTTPException: If the session is invalid.
+        """
+        cookie: str = self._extract_cookie(request)
+        try:
+            session: KratosSessionObject = await kratos_service.whoami(cookie_value=cookie)
+        except KratosSessionInvalidError as e:
+            raise HTTPException(
+                status_code=401,
+                detail="Invalid Credentials",
+            ) from e
+        except KratosOperationError as e:
+            raise HTTPException(
+                status_code=500,
+                detail="Internal Server Error",
+            ) from e
+
+        return session

fastapi_factory_utilities-0.3.1/src/fastapi_factory_utilities/core/services/kratos/__init__.py

@@ -0,0 +1,13 @@
+"""Kratos service module."""
+
+from .exceptions import KratosOperationError, KratosSessionInvalidError
+from .objects import KratosSessionObject
+from .services import KratosService, depends_kratos_service
+
+__all__: list[str] = [
+    "KratosOperationError",
+    "KratosService",
+    "KratosSessionInvalidError",
+    "KratosSessionObject",
+    "depends_kratos_service",
+]

fastapi_factory_utilities-0.3.1/src/fastapi_factory_utilities/core/services/kratos/enums.py

@@ -0,0 +1,11 @@
+"""Provides enums for Kratos."""
+
+from enum import StrEnum
+
+
+class AuthenticatorAssuranceLevelEnum(StrEnum):
+    """Enum for Authenticator Assurance Level (AAL)."""
+
+    AAL1 = "aal1"
+    AAL2 = "aal2"
+    AAL3 = "aal3"

fastapi_factory_utilities-0.3.1/src/fastapi_factory_utilities/core/services/kratos/exceptions.py

@@ -0,0 +1,15 @@
+"""Python exceptions for the Kratos service."""
+
+from fastapi_factory_utilities.core.exceptions import FastAPIFactoryUtilitiesError
+
+
+class KratosError(FastAPIFactoryUtilitiesError):
+    """Base class for all exceptions raised by the Kratos service."""
+
+
+class KratosOperationError(KratosError):
+    """Exception raised when a Kratos operation fails."""
+
+
+class KratosSessionInvalidError(KratosOperationError):
+    """Exception raised when a Kratos session is invalid."""

fastapi_factory_utilities-0.3.1/src/fastapi_factory_utilities/core/services/kratos/objects.py

@@ -0,0 +1,42 @@
+"""Provides the Kratos Objects."""
+
+import datetime
+import uuid
+from typing import ClassVar
+
+from pydantic import BaseModel, ConfigDict
+
+from .enums import AuthenticatorAssuranceLevelEnum
+
+
+class KratosTraitsObject(BaseModel):
+    """Traits for Kratos."""
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra="ignore")
+
+    email: str
+    username: str
+
+
+class KratosIdentityObject(BaseModel):
+    """Identity for Kratos."""
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra="ignore")
+
+    id: uuid.UUID
+    state: str
+    traits: KratosTraitsObject
+
+
+class KratosSessionObject(BaseModel):
+    """Session object for Kratos."""
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra="ignore")
+
+    id: uuid.UUID
+    active: bool
+    issued_at: datetime.datetime
+    expires_at: datetime.datetime
+    authenticated_at: datetime.datetime
+    authenticator_assurance_level: AuthenticatorAssuranceLevelEnum
+    identity: KratosIdentityObject

fastapi_factory_utilities-0.3.1/src/fastapi_factory_utilities/core/services/kratos/services.py

@@ -0,0 +1,86 @@
+"""Provides the KratosService class for handling Kratos operations."""
+
+from http import HTTPStatus
+from typing import Annotated
+
+import aiohttp
+from fastapi import Depends
+from pydantic import ValidationError
+
+from fastapi_factory_utilities.core.app import (
+    DependencyConfig,
+    HttpServiceDependencyConfig,
+    depends_dependency_config,
+)
+
+from .exceptions import KratosOperationError, KratosSessionInvalidError
+from .objects import KratosSessionObject
+
+
+class KratosService:
+    """Service class for handling Kratos operations."""
+
+    COOKIE_NAME: str = "ory_kratos_session"
+
+    def __init__(self, kratos_http_config: HttpServiceDependencyConfig) -> None:
+        """Initialize the KratosService class.
+
+        Args:
+            kratos_http_config (HttpServiceDependencyConfig): Kratos HTTP configuration.
+        """
+        self._http_config: HttpServiceDependencyConfig = kratos_http_config
+
+    async def whoami(self, cookie_value: str) -> KratosSessionObject:
+        """Get the current user session.
+
+        Args:
+            cookie_value (str): Cookie value.
+
+        Returns:
+            KratosSessionObject: Kratos session object.
+
+        Raises:
+            KratosOperationError: If the Kratos service returns an error.
+            KratosSessionInvalidError: If the Kratos session is invalid.
+        """
+        cookies: dict[str, str] = {self.COOKIE_NAME: cookie_value}
+        async with aiohttp.ClientSession(base_url=str(self._http_config.url), cookies=cookies) as session:
+            async with session.get(
+                url="/sessions/whoami",
+            ) as response:
+                if response.status >= HTTPStatus.INTERNAL_SERVER_ERROR.value:
+                    raise KratosOperationError(message=f"Kratos service error: {response.status} - {response.reason}")
+                if response.status == HTTPStatus.UNAUTHORIZED:
+                    raise KratosSessionInvalidError(
+                        message=f"Kratos session invalid: {response.status} - {response.reason}"
+                    )
+                if response.status != HTTPStatus.OK:
+                    raise KratosOperationError(message=f"Kratos service error: {response.status} - {response.reason}")
+
+                try:
+                    kratos_session: KratosSessionObject = KratosSessionObject(**await response.json())
+                except ValidationError as e:
+                    raise KratosOperationError(message=f"Kratos service error: {e}") from e
+
+                return kratos_session
+
+
+def depends_kratos_service(
+    dependency_config: Annotated[DependencyConfig, Depends(depends_dependency_config)],
+) -> KratosService:
+    """Dependency function to get the Kratos service instance.
+
+    Args:
+        dependency_config (DependencyConfig): Dependency configuration.
+
+    Returns:
+        KratosService: Kratos service instance.
+
+    Raises:
+        KratosOperationError: If the Kratos dependency is not configured.
+    """
+    if dependency_config.kratos is None:
+        raise KratosOperationError(message="Kratos dependency not configured")
+    return KratosService(
+        kratos_http_config=dependency_config.kratos,
+    )