fastapi-factory-utilities 0.3.3__py3-none-any.whl → 0.8.2__py3-none-any.whl

fastapi_factory_utilities/core/security/kratos.py

@@ -1,32 +1,39 @@
 """Provide Kratos Session and Identity classes."""
 
-from typing import Annotated
+from http import HTTPStatus
 
-from fastapi import Depends, HTTPException, Request
+from fastapi import HTTPException, Request
 
+from fastapi_factory_utilities.core.security.abstracts import AuthenticationAbstract
 from fastapi_factory_utilities.core.services.kratos import (
     KratosOperationError,
     KratosService,
     KratosSessionInvalidError,
     KratosSessionObject,
-    depends_kratos_service,
 )
 
 
-class KratosSessionAuthentication:
+class KratosSessionAuthenticationService(AuthenticationAbstract):
     """Kratos Session class."""
 
     DEFAULT_COOKIE_NAME: str = "ory_kratos_session"
 
-    def __init__(self, cookie_name: str = DEFAULT_COOKIE_NAME) -> None:
+    def __init__(
+        self, kratos_service: KratosService, cookie_name: str = DEFAULT_COOKIE_NAME, raise_exception: bool = True
+    ) -> None:
         """Initialize the KratosSessionAuthentication class.
 
         Args:
-            cookie_name (str): Name of the cookie to extract the session
+            kratos_service (KratosService): Kratos service object.
+            cookie_name (str): Name of the cookie to extract the session.
+            raise_exception (bool): Whether to raise an exception or return None.
         """
+        self._kratos_service: KratosService = kratos_service
         self._cookie_name: str = cookie_name
+        self._session: KratosSessionObject
+        super().__init__(raise_exception=raise_exception)
 
-    def _extract_cookie(self, request: Request) -> str:
+    def _extract_cookie(self, request: Request) -> str | None:
         """Extract the cookie from the request.
 
         Args:
@@ -38,17 +45,18 @@ class KratosSessionAuthentication:
         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
+        return request.cookies.get(self._cookie_name, None)
+
+    @property
+    def session(self) -> KratosSessionObject:
+        """Get the Kratos session.
+
+        Returns:
+            KratosSessionObject: Kratos session object.
+        """
+        return self._session
 
-    async def __call__(
-        self, request: Request, kratos_service: Annotated[KratosService, Depends(depends_kratos_service)]
-    ) -> KratosSessionObject:
+    async def authenticate(self, request: Request) -> None:
         """Extract the Kratos session from the request.
 
         Args:
@@ -56,23 +64,35 @@ class KratosSessionAuthentication:
             kratos_service (KratosService): Kratos service object.
 
         Returns:
-            KratosSessionObject: Kratos session object.
+            None: If the authentication is successful or not raise_exception is False.
 
         Raises:
-            HTTPException: If the session is invalid.
+            HTTPException: If the session is invalid and raise_exception is True.
         """
-        cookie: str = self._extract_cookie(request)
+        cookie: str | None = self._extract_cookie(request)
+        if not cookie:
+            return self.raise_exception(
+                HTTPException(
+                    status_code=HTTPStatus.UNAUTHORIZED,
+                    detail="Missing Credentials",
+                )
+            )
+
         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
+            self._session = await self._kratos_service.whoami(cookie_value=cookie)
+        except KratosSessionInvalidError:
+            return self.raise_exception(
+                HTTPException(
+                    status_code=HTTPStatus.UNAUTHORIZED,
+                    detail="Invalid Credentials",
+                )
+            )
+        except KratosOperationError:
+            return self.raise_exception(
+                HTTPException(
+                    status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                    detail="Internal Server Error",
+                )
+            )
+
+        return

fastapi_factory_utilities/core/services/hydra/__init__.py

@@ -0,0 +1,20 @@
+"""Hydra service module."""
+
+from .exceptions import HydraOperationError, HydraTokenInvalidError
+from .objects import HydraTokenIntrospectObject
+from .services import (
+    HydraIntrospectService,
+    HydraOAuth2ClientCredentialsService,
+    depends_hydra_introspect_service,
+    depends_hydra_oauth2_client_credentials_service,
+)
+
+__all__: list[str] = [
+    "HydraIntrospectService",
+    "HydraOAuth2ClientCredentialsService",
+    "HydraOperationError",
+    "HydraTokenIntrospectObject",
+    "HydraTokenInvalidError",
+    "depends_hydra_introspect_service",
+    "depends_hydra_oauth2_client_credentials_service",
+]

fastapi_factory_utilities/core/services/hydra/exceptions.py

@@ -0,0 +1,15 @@
+"""Python exceptions for the Hydra service."""
+
+from fastapi_factory_utilities.core.exceptions import FastAPIFactoryUtilitiesError
+
+
+class HydraError(FastAPIFactoryUtilitiesError):
+    """Base class for all exceptions raised by the Hydra service."""
+
+
+class HydraOperationError(HydraError):
+    """Exception raised when a Hydra operation fails."""
+
+
+class HydraTokenInvalidError(HydraError):
+    """Exception raised when a Hydra token is invalid."""

fastapi_factory_utilities/core/services/hydra/objects.py

@@ -0,0 +1,26 @@
+"""Provides the objects for the Hydra service."""
+
+from typing import ClassVar
+
+from pydantic import BaseModel, ConfigDict
+
+
+class HydraTokenIntrospectObject(BaseModel):
+    """Represents the object returned by the Hydra token introspection."""
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra="ignore")
+
+    active: bool
+    aud: list[str]
+    client_id: str
+    exp: int
+    ext: dict[str, str] | None = None
+    iat: int
+    iss: str
+    nbf: int
+    obfuscated_subject: str | None = None
+    scope: str
+    sub: str
+    token_type: str
+    token_use: str
+    username: str | None = None

fastapi_factory_utilities/core/services/hydra/services.py

@@ -0,0 +1,200 @@
+"""Provides a service to interact with the Hydra service."""
+
+import json
+from base64 import b64encode
+from http import HTTPStatus
+from typing import Annotated, Any, Generic, TypeVar, get_args
+
+import aiohttp
+import jwt
+from fastapi import Depends
+from pydantic import ValidationError
+
+from fastapi_factory_utilities.core.app import (
+    DependencyConfig,
+    HttpServiceDependencyConfig,
+    depends_dependency_config,
+)
+
+from .exceptions import HydraOperationError
+from .objects import HydraTokenIntrospectObject
+
+HydraIntrospectObjectGeneric = TypeVar("HydraIntrospectObjectGeneric", bound=HydraTokenIntrospectObject)
+
+
+class HydraIntrospectGenericService(Generic[HydraIntrospectObjectGeneric]):
+    """Service to interact with the Hydra introspect service with a generic introspect object."""
+
+    INTROSPECT_ENDPOINT: str = "/admin/oauth2/introspect"
+    WELLKNOWN_JWKS_ENDPOINT: str = "/.well-known/jwks.json"
+
+    def __init__(
+        self,
+        hydra_admin_http_config: HttpServiceDependencyConfig,
+        hydra_public_http_config: HttpServiceDependencyConfig,
+    ) -> None:
+        """Instanciate the Hydra introspect service.
+
+        Args:
+            hydra_admin_http_config (HttpServiceDependencyConfig): The Hydra admin HTTP configuration.
+            hydra_public_http_config (HttpServiceDependencyConfig): The Hydra public HTTP configuration.
+        """
+        self._hydra_admin_http_config: HttpServiceDependencyConfig = hydra_admin_http_config
+        self._hydra_public_http_config: HttpServiceDependencyConfig = hydra_public_http_config
+        # Retrieve the concrete introspect object class
+        generic_args: tuple[Any, ...] = get_args(self.__orig_bases__[0])  # type: ignore
+        self._concreate_introspect_object_class: type[HydraIntrospectObjectGeneric] = generic_args[0]
+
+    async def introspect(self, token: str) -> HydraIntrospectObjectGeneric:
+        """Introspects a token using the Hydra introspect service.
+
+        Args:
+            token (str): The token to introspect.
+        """
+        try:
+            async with aiohttp.ClientSession(
+                base_url=str(self._hydra_admin_http_config.url),
+            ) as session:
+                async with session.post(
+                    url=self.INTROSPECT_ENDPOINT,
+                    data={"token": token},
+                ) as response:
+                    response.raise_for_status()
+                    instrospect: HydraIntrospectObjectGeneric = self._concreate_introspect_object_class.model_validate(
+                        await response.json()
+                    )
+        except aiohttp.ClientResponseError as error:
+            raise HydraOperationError("Failed to introspect the token", status_code=error.status) from error
+        except json.JSONDecodeError as error:
+            raise HydraOperationError("Failed to decode the introspect response") from error
+        except ValidationError as error:
+            raise HydraOperationError("Failed to validate the introspect response") from error
+
+        return instrospect
+
+    async def get_wellknown_jwks(self) -> jwt.PyJWKSet:
+        """Get the JWKS from the Hydra service."""
+        try:
+            async with aiohttp.ClientSession(
+                base_url=str(self._hydra_public_http_config.url),
+            ) as session:
+                async with session.get(
+                    url=self.WELLKNOWN_JWKS_ENDPOINT,
+                ) as response:
+                    response.raise_for_status()
+                    jwks_data: dict[str, Any] = await response.json()
+                    jwks: jwt.PyJWKSet = jwt.PyJWKSet.from_dict(jwks_data)
+                    return jwks
+        except aiohttp.ClientResponseError as error:
+            raise HydraOperationError(
+                "Failed to get the JWKS from the Hydra service", status_code=error.status
+            ) from error
+        except json.JSONDecodeError as error:
+            raise HydraOperationError("Failed to decode the JWKS from the Hydra service") from error
+        except ValidationError as error:
+            raise HydraOperationError("Failed to validate the JWKS from the Hydra service") from error
+
+
+class HydraIntrospectService(HydraIntrospectGenericService[HydraTokenIntrospectObject]):
+    """Service to interact with the Hydra introspect service with the default HydraTokenIntrospectObject."""
+
+
+class HydraOAuth2ClientCredentialsService:
+    """Service to interact with the Hydra service."""
+
+    INTROSPECT_ENDPOINT: str = "/admin/oauth2/introspect"
+    CLIENT_CREDENTIALS_ENDPOINT: str = "/oauth2/token"
+
+    def __init__(
+        self,
+        hydra_public_http_config: HttpServiceDependencyConfig,
+    ) -> None:
+        """Instanciate the Hydra service.
+
+        Args:
+            hydra_admin_http_config (HttpServiceDependencyConfig): The Hydra admin HTTP configuration.
+            hydra_public_http_config (HttpServiceDependencyConfig): The Hydra public HTTP configuration.
+        """
+        self._hydra_public_http_config: HttpServiceDependencyConfig = hydra_public_http_config
+
+    async def oauth2_client_credentials(self, client_id: str, client_secret: str, scope: str) -> str:
+        """Get the OAuth2 client credentials.
+
+        Args:
+            client_id (str): The client ID.
+            client_secret (str): The client secret.
+            scope (str): The scope.
+
+        Returns:
+            str: The access token.
+
+        Raises:
+            HydraOperationError: If the client credentials request fails.
+        """
+        # Create base64 encoded Basic Auth header
+        auth_string = f"{client_id}:{client_secret}"
+        auth_bytes = auth_string.encode("utf-8")
+        auth_b64 = b64encode(auth_bytes).decode("utf-8")
+
+        async with aiohttp.ClientSession(
+            base_url=str(self._hydra_public_http_config.url),
+        ) as session:
+            async with session.post(
+                url=self.CLIENT_CREDENTIALS_ENDPOINT,
+                headers={"Authorization": f"Basic {auth_b64}"},
+                data={"grant_type": "client_credentials", "scope": scope},
+            ) as response:
+                response_data = await response.json()
+                if response.status != HTTPStatus.OK:
+                    raise HydraOperationError(f"Failed to get client credentials: {response_data}")
+
+                return response_data["access_token"]
+
+
+def depends_hydra_oauth2_client_credentials_service(
+    dependency_config: Annotated[DependencyConfig, Depends(depends_dependency_config)],
+) -> HydraOAuth2ClientCredentialsService:
+    """Dependency injection for the Hydra OAuth2 client credentials service.
+
+    Args:
+        dependency_config (DependencyConfig): The dependency configuration.
+
+    Returns:
+        HydraOAuth2ClientCredentialsService: The Hydra OAuth2 client credentials service instance.
+
+    Raises:
+        HydraOperationError: If the Hydra public dependency is not configured.
+    """
+    if dependency_config.hydra_public is None:
+        raise HydraOperationError(message="Hydra public dependency not configured")
+
+    return HydraOAuth2ClientCredentialsService(
+        hydra_public_http_config=dependency_config.hydra_public,
+    )
+
+
+def depends_hydra_introspect_service(
+    dependency_config: Annotated[DependencyConfig, Depends(depends_dependency_config)],
+) -> HydraIntrospectService:
+    """Dependency injection for the Hydra introspect service.
+
+    Args:
+        dependency_config (DependencyConfig): The dependency configuration.
+
+    Returns:
+        HydraIntrospectService: The Hydra introspect service instance.
+
+    Raises:
+        HydraOperationError: If the Hydra admin dependency is not configured.
+    """
+    if getattr(dependency_config, "hydra_admin", None) is None:
+        raise HydraOperationError(message="Hydra admin dependency not configured")
+    assert dependency_config.hydra_admin is not None
+    if getattr(dependency_config, "hydra_public", None) is None:
+        raise HydraOperationError(message="Hydra public dependency not configured")
+    assert dependency_config.hydra_public is not None
+
+    return HydraIntrospectService(
+        hydra_admin_http_config=dependency_config.hydra_admin,
+        hydra_public_http_config=dependency_config.hydra_public,
+    )

fastapi_factory_utilities/core/services/status/__init__.py

@@ -5,10 +5,10 @@ from .services import StatusService
 from .types import ComponentInstanceType, Status
 
 __all__: list[str] = [
-    "ComponentTypeEnum",
     "ComponentInstanceType",
+    "ComponentTypeEnum",
     "HealthStatusEnum",
     "ReadinessStatusEnum",
-    "StatusService",
     "Status",
+    "StatusService",
 ]

fastapi_factory_utilities/core/services/status/exceptions.py

@@ -23,5 +23,5 @@ class ComponentRegistrationError(StatusServiceError):
         """
         super().__init__(
             message="An error occurred while registering the component instance.",
-            component_instance=component_instance,  # type: ignore
+            component_instance=component_instance,
         )

fastapi_factory_utilities/core/utils/status.py

@@ -3,6 +3,7 @@
 ```python
 # Example of using the MonitoredAbstract
 
+
 class MyMonitored(MonitoredAbstract):
     def __init__(self, status_service: StatusService) -> None:
         super().__init__(
@@ -63,9 +64,9 @@ class MonitoredAbstract(ABC):
 
 
 __all__: list[str] = [
-    "MonitoredAbstract",
     "ComponentInstanceType",
     "ComponentTypeEnum",
+    "MonitoredAbstract",
     "Status",
     "StatusService",
 ]

fastapi_factory_utilities/core/utils/yaml_reader.py

@@ -72,7 +72,7 @@ class YamlFileReader:
                 try:
                     yaml_data = yaml_data[key]
                 except KeyError:
-                    logger.warning(f"Base key {key}" " not found in YAML file" + " from {self._yaml_base_key}")
+                    logger.warning(f"Base key {key} not found in YAML file" + " from {self._yaml_base_key}")
                     return dict()
         return yaml_data
 

fastapi_factory_utilities/example/app.py

@@ -7,7 +7,9 @@ from beanie import Document
 from fastapi_factory_utilities.core.app.application import ApplicationAbstract
 from fastapi_factory_utilities.core.app.builder import ApplicationGenericBuilder
 from fastapi_factory_utilities.core.app.config import RootConfig
-from fastapi_factory_utilities.core.plugins import PluginsEnum
+from fastapi_factory_utilities.core.plugins.abstracts import PluginAbstract
+from fastapi_factory_utilities.core.plugins.odm_plugin import ODMPlugin
+from fastapi_factory_utilities.core.plugins.opentelemetry_plugin import OpenTelemetryPlugin
 from fastapi_factory_utilities.example.models.books.document import BookDocument
 
 
@@ -26,12 +28,11 @@ class App(ApplicationAbstract):
 
     ODM_DOCUMENT_MODELS: ClassVar[list[type[Document]]] = [BookDocument]
 
-    DEFAULT_PLUGINS_ACTIVATED: ClassVar[list[PluginsEnum]] = [PluginsEnum.OPENTELEMETRY_PLUGIN, PluginsEnum.ODM_PLUGIN]
-
     def configure(self) -> None:
         """Configure the application."""
         # Prevent circular import
-        from .api import api_router  # pylint: disable=import-outside-toplevel
+        # pylint: disable=import-outside-toplevel
+        from .api import api_router  # noqa: PLC0415
 
         self.get_asgi_app().include_router(router=api_router)
 
@@ -47,4 +48,13 @@ class App(ApplicationAbstract):
 class AppBuilder(ApplicationGenericBuilder[App]):
     """Application builder for the App application."""
 
-    pass
+    def get_default_plugins(self) -> list[PluginAbstract]:
+        """Get the default plugins."""
+        return [ODMPlugin(), OpenTelemetryPlugin()]
+
+    def __init__(self, plugins: list[PluginAbstract] | None = None) -> None:
+        """Initialize the AppBuilder."""
+        # If no plugins are provided, use the default plugins
+        if plugins is None:
+            plugins = self.get_default_plugins()
+        super().__init__(plugins=plugins)

fastapi_factory_utilities/example/entities/books/__init__.py

@@ -4,4 +4,4 @@ from .entities import BookEntity
 from .enums import BookType
 from .types import BookName
 
-__all__: list[str] = ["BookEntity", "BookType", "BookName"]
+__all__: list[str] = ["BookEntity", "BookName", "BookType"]

fastapi_factory_utilities/example/models/books/__init__.py

@@ -3,4 +3,4 @@
 from .document import BookDocument
 from .repository import BookRepository
 
-__all__: list[str] = ["BookRepository", "BookDocument"]
+__all__: list[str] = ["BookDocument", "BookRepository"]

{fastapi_factory_utilities-0.3.3.dist-info → fastapi_factory_utilities-0.8.2.dist-info}/METADATA

@@ -1,9 +1,10 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: fastapi_factory_utilities
-Version: 0.3.3
-Summary: Consolidate libraries and utilities to create microservices in Python with FastAPI, Beanie, Httpx, AioPika and OpenTelemetry.
+Version: 0.8.2
+Summary: Consolidate libraries and utilities to create microservices in Python with FastAPI, Beanie, Taskiq, AioPika and OpenTelemetry.
 License: MIT
-Keywords: python,fastapi,beanie,httpx,opentelemetry,microservices
+License-File: LICENSE
+Keywords: python,fastapi,beanie,taskiq,opentelemetry,microservices
 Author: miragecentury
 Author-email: victorien.vanroye@gmail.com
 Maintainer: miragecentury
@@ -18,26 +19,31 @@ 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)
+Requires-Dist: aio-pika (>=9.5.7,<10.0.0)
+Requires-Dist: aiohttp[speedups] (>=3.12.13,<4.0.0)
+Requires-Dist: beanie (>=1.30.0,<2.0.0)
+Requires-Dist: fastapi (>=0.115.13,<1)
 Requires-Dist: opentelemetry-exporter-otlp-proto-grpc (>=1.26.0,<2.0.0)
 Requires-Dist: opentelemetry-exporter-otlp-proto-http (>=1.26.0,<2.0.0)
-Requires-Dist: opentelemetry-instrumentation-fastapi (>=0.49b1,<0.50)
-Requires-Dist: opentelemetry-instrumentation-pymongo (>=0.49b2,<0.50)
+Requires-Dist: opentelemetry-instrumentation-aio-pika (>=0.59b0,<0.60)
+Requires-Dist: opentelemetry-instrumentation-aiohttp-client (>=0,<1)
+Requires-Dist: opentelemetry-instrumentation-fastapi (>=0,<1)
+Requires-Dist: opentelemetry-instrumentation-pymongo (>=0,<1)
 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: pymongo (>=4.9.2,<4.16.0)
 Requires-Dist: reactivex (>=4.0.4,<5.0.0)
 Requires-Dist: structlog (>=24.1,<26.0)
-Requires-Dist: typer (>=0.15.1,<0.16.0)
-Requires-Dist: uvicorn (>=0.32.0,<0.33.0)
-Project-URL: Homepage, https://github.com/miragecentury/fastapi_factory_utilities
-Project-URL: Repository, https://github.com/miragecentury/fastapi_factory_utilities
+Requires-Dist: taskiq-dependencies (>=1.5.8,<2.0.0)
+Requires-Dist: taskiq-fastapi (>=0.3.5,<0.4.0)
+Requires-Dist: taskiq-redis (>=1.0.9,<2.0.0)
+Requires-Dist: typer (>=0,<1)
+Requires-Dist: uvicorn (>=0.34.3,<1)
+Project-URL: Homepage, https://github.com/DeerHide/fastapi_factory_utilities
+Project-URL: Repository, https://github.com/DeerHide/fastapi_factory_utilities
 Description-Content-Type: text/markdown
 
 # fastapi_factory_utilities