fastapi-factory-utilities 0.8.1__tar.gz → 0.8.2__tar.gz

{fastapi_factory_utilities-0.8.1 → fastapi_factory_utilities-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi_factory_utilities
-Version: 0.8.1
+Version: 0.8.2
 Summary: Consolidate libraries and utilities to create microservices in Python with FastAPI, Beanie, Taskiq, AioPika and OpenTelemetry.
 License: MIT
 License-File: LICENSE

{fastapi_factory_utilities-0.8.1 → fastapi_factory_utilities-0.8.2}/pyproject.toml

@@ -3,7 +3,7 @@ name = "fastapi_factory_utilities"
 homepage = "https://github.com/DeerHide/fastapi_factory_utilities"
 repository = "https://github.com/DeerHide/fastapi_factory_utilities"
 keywords = ["python", "fastapi", "beanie", "taskiq", "opentelemetry", "microservices"]
-version = "0.8.1"
+version = "0.8.2"
 description = "Consolidate libraries and utilities to create microservices in Python with FastAPI, Beanie, Taskiq, AioPika and OpenTelemetry."
 authors = ["miragecentury <victorien.vanroye@gmail.com>"]
 maintainers = ["miragecentury <victorien.vanroye@gmail.com>"]

fastapi_factory_utilities-0.8.2/src/fastapi_factory_utilities/core/security/__init__.py

@@ -0,0 +1,5 @@
+"""Security module."""
+
+from .abstracts import AuthenticationAbstract
+
+__all__: list[str] = ["AuthenticationAbstract"]

fastapi_factory_utilities-0.8.2/src/fastapi_factory_utilities/core/security/abstracts.py

@@ -0,0 +1,42 @@
+"""Provides the security authentication abstract classes."""
+
+from abc import ABC, abstractmethod
+
+from fastapi import Request
+
+
+class AuthenticationAbstract(ABC):
+    """Authentication abstract class."""
+
+    def __init__(self, raise_exception: bool = True) -> None:
+        """Initialize the authentication abstract class.
+
+        Args:
+            raise_exception (bool): Whether to raise an exception or return None.
+        """
+        self._raise_exception: bool = raise_exception
+        self._errors: list[Exception] = []
+
+    def has_errors(self) -> bool:
+        """Check if the authentication has errors.
+
+        Returns:
+            bool: True if the authentication has errors, False otherwise.
+        """
+        return len(self._errors) > 0
+
+    def raise_exception(self, exception: Exception) -> None:
+        """Raise the exception if the authentication has errors.
+
+        Args:
+            exception (Exception): The exception to raise.
+        """
+        if self._raise_exception:
+            raise exception
+        else:
+            self._errors.append(exception)
+
+    @abstractmethod
+    async def authenticate(self, request: Request) -> None:
+        """Authenticate the request."""
+        raise NotImplementedError()

{fastapi_factory_utilities-0.8.1 → fastapi_factory_utilities-0.8.2}/src/fastapi_factory_utilities/core/security/jwt/services.py

@@ -1,9 +1,11 @@
 """Provides the JWT bearer authentication service."""
 
-from abc import ABC
+from http import HTTPStatus
 from typing import Generic, TypeVar
 
-from fastapi import Request
+from fastapi import HTTPException, Request
+
+from fastapi_factory_utilities.core.security.abstracts import AuthenticationAbstract
 
 from .configs import JWTBearerAuthenticationConfig
 from .decoders import JWTBearerTokenDecoder, JWTBearerTokenDecoderAbstract
@@ -16,7 +18,7 @@ from .verifiers import JWTNoneVerifier, JWTVerifierAbstract
 JWTBearerPayloadGeneric = TypeVar("JWTBearerPayloadGeneric", bound=JWTPayload)
 
 
-class JWTAuthenticationServiceAbstract(ABC, Generic[JWTBearerPayloadGeneric]):
+class JWTAuthenticationServiceAbstract(AuthenticationAbstract, Generic[JWTBearerPayloadGeneric]):
     """JWT authentication service.
 
     This service is the orchestrator for the JWT bearer authentication.
@@ -45,9 +47,7 @@ class JWTAuthenticationServiceAbstract(ABC, Generic[JWTBearerPayloadGeneric]):
         # Runtime variables
         self._jwt: JWTToken | None = None
         self._jwt_payload: JWTBearerPayloadGeneric | None = None
-        # Exception handling for multi-authentication methods support
-        self._raise_exception: bool = raise_exception
-        self._errors: list[Exception] = []
+        super().__init__(raise_exception=raise_exception)
 
     @property
     def verifier(self) -> JWTVerifierAbstract[JWTBearerPayloadGeneric]:
@@ -102,20 +102,12 @@ class JWTAuthenticationServiceAbstract(ABC, Generic[JWTBearerPayloadGeneric]):
             raise InvalidJWTError(message="Invalid Credentials")
         return JWTToken(authorization_header.split(sep=" ")[1])
 
-    def has_errors(self) -> bool:
-        """Check if the service has errors.
-
-        Returns:
-            bool: True if the service has errors, False otherwise.
-        """
-        return len(self._errors) > 0
-
     @property
     def payload(self) -> JWTBearerPayloadGeneric | None:
         """Get the JWT bearer payload.
 
         Returns:
-            JWTBearerPayloadGeneric | None: The JWT bearer payload.
+            JWTBearerPayloadGeneric | None: The JWT bearer payload, or None if not authenticated yet.
         """
         return self._jwt_payload
 
@@ -139,26 +131,17 @@ class JWTAuthenticationServiceAbstract(ABC, Generic[JWTBearerPayloadGeneric]):
             authorization_header = self.extract_authorization_header_from_request(request=request)
             self._jwt = self.extract_bearer_token_from_authorization_header(authorization_header=authorization_header)
         except (MissingJWTCredentialsError, InvalidJWTError) as e:
-            if not self._raise_exception:
-                self._errors.append(e)
-                return
-            raise
+            return self.raise_exception(HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail=str(e)))
 
         try:
             self._jwt_payload = await self._jwt_decoder.decode_payload(jwt_token=self._jwt)
         except (InvalidJWTError, InvalidJWTPayploadError) as e:
-            if not self._raise_exception:
-                self._errors.append(e)
-                return
-            raise
+            return self.raise_exception(HTTPException(status_code=HTTPStatus.FORBIDDEN, detail=str(e)))
 
         try:
             await self._jwt_verifier.verify(jwt_token=self._jwt, jwt_payload=self._jwt_payload)
         except NotVerifiedJWTError as e:
-            if not self._raise_exception:
-                self._errors.append(e)
-                return
-            raise
+            return self.raise_exception(HTTPException(status_code=HTTPStatus.FORBIDDEN, detail=str(e)))
 
         return
 

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

@@ -0,0 +1,98 @@
+"""Provide Kratos Session and Identity classes."""
+
+from http import HTTPStatus
+
+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,
+)
+
+
+class KratosSessionAuthenticationService(AuthenticationAbstract):
+    """Kratos Session class."""
+
+    DEFAULT_COOKIE_NAME: str = "ory_kratos_session"
+
+    def __init__(
+        self, kratos_service: KratosService, cookie_name: str = DEFAULT_COOKIE_NAME, raise_exception: bool = True
+    ) -> None:
+        """Initialize the KratosSessionAuthentication class.
+
+        Args:
+            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 | None:
+        """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.
+        """
+        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 authenticate(self, request: Request) -> None:
+        """Extract the Kratos session from the request.
+
+        Args:
+            request (Request): FastAPI request object.
+            kratos_service (KratosService): Kratos service object.
+
+        Returns:
+            None: If the authentication is successful or not raise_exception is False.
+
+        Raises:
+            HTTPException: If the session is invalid and raise_exception is True.
+        """
+        cookie: str | None = self._extract_cookie(request)
+        if not cookie:
+            return self.raise_exception(
+                HTTPException(
+                    status_code=HTTPStatus.UNAUTHORIZED,
+                    detail="Missing Credentials",
+                )
+            )
+
+        try:
+            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-0.8.1 → fastapi_factory_utilities-0.8.2}/src/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-0.8.1/src/fastapi_factory_utilities/core/security/__init__.py

@@ -1,5 +0,0 @@
-"""Security module."""
-
-from .flags import AuthenticationMethodsFlag
-
-__all__: list[str] = ["AuthenticationMethodsFlag"]

fastapi_factory_utilities-0.8.1/src/fastapi_factory_utilities/core/security/flags.py

@@ -1,10 +0,0 @@
-"""Provides flags for security."""
-
-from enum import Flag, auto
-
-
-class AuthenticationMethodsFlag(Flag):
-    """Authentication Flags."""
-
-    JWT = auto()
-    KRATOS = auto()

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

@@ -1,98 +0,0 @@
-"""Provide Kratos Session and Identity classes."""
-
-from enum import StrEnum
-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 KratosSessionAuthenticationErrors(StrEnum):
-    """Kratos Session Authentication Errors."""
-
-    MISSING_CREDENTIALS = "Missing Credentials"
-    INVALID_CREDENTIALS = "Invalid Credentials"
-    INTERNAL_SERVER_ERROR = "Internal Server Error"
-
-
-class KratosSessionAuthentication:
-    """Kratos Session class."""
-
-    DEFAULT_COOKIE_NAME: str = "ory_kratos_session"
-
-    def __init__(self, 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
-            raise_exception (bool): Whether to raise an exception or return None
-        """
-        self._cookie_name: str = cookie_name
-        self._raise_exception: bool = raise_exception
-
-    def _extract_cookie(self, request: Request) -> str | None:
-        """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.
-        """
-        return request.cookies.get(self._cookie_name, None)
-
-    async def __call__(
-        self, request: Request, kratos_service: Annotated[KratosService, Depends(depends_kratos_service)]
-    ) -> KratosSessionObject | KratosSessionAuthenticationErrors:
-        """Extract the Kratos session from the request.
-
-        Args:
-            request (Request): FastAPI request object.
-            kratos_service (KratosService): Kratos service object.
-
-        Returns:
-            KratosSessionObject | KratosSessionAuthenticationErrors: Kratos session object or error.
-
-        Raises:
-            HTTPException: If the session is invalid and raise_exception is True.
-        """
-        cookie: str | None = self._extract_cookie(request)
-        if not cookie:
-            if self._raise_exception:
-                raise HTTPException(
-                    status_code=401,
-                    detail=KratosSessionAuthenticationErrors.MISSING_CREDENTIALS,
-                )
-            else:
-                return KratosSessionAuthenticationErrors.MISSING_CREDENTIALS
-
-        try:
-            session: KratosSessionObject = await kratos_service.whoami(cookie_value=cookie)
-        except KratosSessionInvalidError as e:
-            if self._raise_exception:
-                raise HTTPException(
-                    status_code=401,
-                    detail="Invalid Credentials",
-                ) from e
-            else:
-                return KratosSessionAuthenticationErrors.INVALID_CREDENTIALS
-        except KratosOperationError as e:
-            if self._raise_exception:
-                raise HTTPException(
-                    status_code=500,
-                    detail="Internal Server Error",
-                ) from e
-            else:
-                return KratosSessionAuthenticationErrors.INTERNAL_SERVER_ERROR
-
-        return session