fastapi-factory-utilities 0.2.11__py3-none-any.whl → 0.3.0__py3-none-any.whl

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/core/plugins/odm_plugin/repositories.py

@@ -6,7 +6,6 @@ from collections.abc import AsyncGenerator, Callable
 from contextlib import asynccontextmanager
 from typing import Any, Generic, TypeVar, get_args
 from uuid import UUID
-from venv import create
 
 from motor.motor_asyncio import AsyncIOMotorClientSession, AsyncIOMotorDatabase
 from pydantic import BaseModel
@@ -79,7 +78,7 @@ class AbstractRepository(ABC, Generic[DocumentGenericType, EntityGenericType]):
             UnableToCreateEntityDueToDuplicateKeyError: If the entity cannot be created due to a duplicate key error.
             OperationError: If the operation fails.
         """
-        insert_time: datetime.datetime = datetime.datetime.now(tz=datetime.timezone.utc)
+        insert_time: datetime.datetime = datetime.datetime.now(tz=datetime.UTC)
         try:
             entity_dump: dict[str, Any] = entity.model_dump()
             entity_dump["created_at"] = insert_time
@@ -120,7 +119,7 @@ class AbstractRepository(ABC, Generic[DocumentGenericType, EntityGenericType]):
             ValueError: If the entity cannot be created from the document.
             OperationError: If the operation fails.
         """
-        update_time: datetime.datetime = datetime.datetime.now(tz=datetime.timezone.utc)
+        update_time: datetime.datetime = datetime.datetime.now(tz=datetime.UTC)
         try:
             entity_dump: dict[str, Any] = entity.model_dump()
             entity_dump["updated_at"] = update_time

fastapi_factory_utilities/core/plugins/opentelemetry_plugin/builder.py

@@ -1,9 +1,20 @@
 """Provides a factory function to build a objets for OpenTelemetry."""
 
 from typing import Any, Self
+from urllib.parse import ParseResult, urlparse
 
-from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
-from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import (
+    OTLPMetricExporter as OTLPMetricExporterGRPC,
+)
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
+    OTLPSpanExporter as OTLPSpanExporterGRPC,
+)
+from opentelemetry.exporter.otlp.proto.http.metric_exporter import (
+    OTLPMetricExporter as OTLPMetricExporterHTTP,
+)
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+    OTLPSpanExporter as OTLPSpanExporterHTTP,
+)
 from opentelemetry.metrics import set_meter_provider
 from opentelemetry.propagate import set_global_textmap
 from opentelemetry.propagators.b3 import B3MultiFormat
@@ -31,24 +42,30 @@ from fastapi_factory_utilities.core.utils.yaml_reader import (
     YamlFileReader,
 )
 
-from .configs import OpenTelemetryConfig
+from .configs import OpenTelemetryConfig, ProtocolEnum
 from .exceptions import OpenTelemetryPluginConfigError
 
+GRPC_PORT: int = 4317
+HTTP_PORT: int = 4318
+
 
 class OpenTelemetryPluginBuilder:
     """Configure the injection bindings for OpenTelemetryPlugin."""
 
-    def __init__(self, application: ApplicationAbstractProtocol) -> None:
+    def __init__(self, application: ApplicationAbstractProtocol, settings: OpenTelemetryConfig | None = None) -> None:
         """Instantiate the OpenTelemetryPluginFactory.
 
         Args:
             application (BaseApplicationProtocol): The application object.
+            settings (OpenTelemetryConfig | None): The OpenTelemetry configuration object.
         """
         self._application: ApplicationAbstractProtocol = application
         self._resource: Resource | None = None
-        self._config: OpenTelemetryConfig | None = None
+        self._config: OpenTelemetryConfig | None = settings
         self._meter_provider: MeterProvider | None = None
         self._tracer_provider: TracerProvider | None = None
+        self._trace_exporter: OTLPSpanExporterGRPC | OTLPSpanExporterHTTP | None = None
+        self._metric_exporter: OTLPMetricExporterGRPC | OTLPMetricExporterHTTP | None = None
 
     @property
     def resource(self) -> Resource | None:
@@ -161,12 +178,27 @@ class OpenTelemetryPluginBuilder:
 
             # TODO: Extract to a dedicated method for the exporter and period reader setup
 
+            url_parsed: ParseResult = urlparse(self._config.endpoint.unicode_string())
+
+            exporter: OTLPMetricExporterGRPC | OTLPMetricExporterHTTP
             # Setup the Exporter
-            exporter = OTLPMetricExporter(
-                endpoint=f"{self._config.endpoint.unicode_string()}",
-                timeout=self._config.timeout,
-                insecure=True if str(self._config.endpoint).startswith("http") else False,
-            )
+            if url_parsed.port == GRPC_PORT or self._config.protocol == ProtocolEnum.OTLP_GRPC:
+                exporter = OTLPMetricExporterGRPC(
+                    endpoint=f"{self._config.endpoint.unicode_string()}",
+                    timeout=self._config.timeout,
+                    insecure=True if str(self._config.endpoint).startswith("http") else False,
+                )
+            elif url_parsed.port == HTTP_PORT or self._config.protocol == ProtocolEnum.OTLP_HTTP:
+                exporter = OTLPMetricExporterHTTP(
+                    endpoint=f"{self._config.endpoint.unicode_string()}/v1/metrics",
+                    timeout=self._config.timeout,
+                )
+            else:
+                raise OpenTelemetryPluginConfigError(
+                    "The endpoint port is not supported. Use 4317 for gRPC or 4318 for HTTP or set the protocol."
+                )
+
+            self._metric_exporter = exporter
 
             # Setup the Metric Reader
             meter_config: OpenTelemetryMeterConfig = self._config.meter_config
@@ -214,12 +246,28 @@ class OpenTelemetryPluginBuilder:
             if self._config.tracer_config is None:
                 raise OpenTelemetryPluginConfigError("The tracer configuration is missing.")
 
+            exporter: OTLPSpanExporterGRPC | OTLPSpanExporterHTTP
+            url_parsed: ParseResult = urlparse(self._config.endpoint.unicode_string())
             # Setup the Exporter
-            exporter = OTLPSpanExporter(
-                endpoint=f"{self._config.endpoint.unicode_string()}",
-                timeout=self._config.timeout,
-                insecure=True if str(self._config.endpoint).startswith("http") else False,
-            )
+            if url_parsed.port == GRPC_PORT or self._config.protocol == ProtocolEnum.OTLP_GRPC:
+                insecure: bool = False if str(self._config.endpoint).startswith("https") else True
+                endpoint: str = f"{self._config.endpoint.unicode_string()}"
+                exporter = OTLPSpanExporterGRPC(
+                    endpoint=endpoint,
+                    # timeout=self._config.timeout,
+                    insecure=insecure,
+                )
+            elif url_parsed.port == HTTP_PORT or self._config.protocol == ProtocolEnum.OTLP_HTTP:
+                exporter = OTLPSpanExporterHTTP(
+                    endpoint=f"{self._config.endpoint.unicode_string()}/v1/traces",
+                    # timeout=self._config.timeout,
+                )
+            else:
+                raise OpenTelemetryPluginConfigError(
+                    "The endpoint port is not supported. Use 4317 for gRPC or 4318 for HTTP or set the protocol."
+                )
+
+            self._trace_exporter = exporter
 
             # Setup the Span Processor
             tracer_config: OpenTelemetryTracerConfig = self._config.tracer_config
@@ -261,7 +309,8 @@ class OpenTelemetryPluginBuilder:
             Self: The OpenTelemetryPluginFactory object.
         """
         self.build_resource()
-        self.build_config()
+        if self._config is None:
+            self.build_config()
         self.build_meter_provider()
         self.build_tracer_provider()
 

fastapi_factory_utilities/core/plugins/opentelemetry_plugin/configs.py

@@ -1,11 +1,19 @@
 """Provides the configuration model for the OpenTelemetry plugin."""
 
+from enum import StrEnum
 from typing import Annotated
 
 from pydantic import BaseModel, ConfigDict, Field, UrlConstraints
 from pydantic_core import Url
 
 
+class ProtocolEnum(StrEnum):
+    """Defines the protocol enum for OpenTelemetry."""
+
+    OTLP_GRPC = "otlp_grpc"
+    OTLP_HTTP = "otlp_http"
+
+
 class OpenTelemetryMeterConfig(BaseModel):
     """Provides the configuration model for the OpenTelemetry meter as sub-model."""
 
@@ -77,6 +85,11 @@ class OpenTelemetryConfig(BaseModel):
         description="The collector endpoint.",
     )
 
+    protocol: ProtocolEnum | None = Field(
+        default=None,
+        description="The protocol to use for the collector.",
+    )
+
     timeout: int = Field(
         default=TEN_SECONDS_IN_SECONDS,
         description="The timeout in seconds for the collector.",

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/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/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/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/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/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/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,
+    )

{fastapi_factory_utilities-0.2.11.dist-info → fastapi_factory_utilities-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fastapi_factory_utilities
-Version: 0.2.11
+Version: 0.3.0
 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.11.dist-info → fastapi_factory_utilities-0.3.0.dist-info}/RECORD

@@ -8,7 +8,7 @@ fastapi_factory_utilities/core/api/v1/sys/readiness.py,sha256=xIY8pQLShU7KWRtlOU
 fastapi_factory_utilities/core/app/__init__.py,sha256=I04abOkkWiY9ChgkUNeiwnuWq8kkBoRAtMLBUKB7J7Y,405
 fastapi_factory_utilities/core/app/application.py,sha256=WrDXh00r_jzQTtZGeFO43lIzvDraplitejTaSJj_uFE,5091
 fastapi_factory_utilities/core/app/builder.py,sha256=VbThqoI1qWnADwPQ61D774oNZ5d6OMxW0tyXr_Yz5E4,4503
-fastapi_factory_utilities/core/app/config.py,sha256=7ELIoCy1AGCD4Zq7O-jZk6VJcqDU8H-00CSrvtwzdZE,6466
+fastapi_factory_utilities/core/app/config.py,sha256=81KYoxB14TX05jMWujPNjLI1BXkvMnUyw2VgF7nJIE0,7063
 fastapi_factory_utilities/core/app/enums.py,sha256=X1upnaehYU0eHExXTde5xsH-pI9q7HZDNsOEF5PApdg,226
 fastapi_factory_utilities/core/app/exceptions.py,sha256=tQDf0_4j5xgCbku7TL7JaZGs3_bjsWG2YLBCydQJpPw,664
 fastapi_factory_utilities/core/app/fastapi_builder.py,sha256=DgIqiCnJK6cqsG-sg4H7Pi0lkhaxOhSLQt_ksHjpjW0,2835
@@ -25,13 +25,20 @@ fastapi_factory_utilities/core/plugins/odm_plugin/configs.py,sha256=zQoJC1wLNyq2
 fastapi_factory_utilities/core/plugins/odm_plugin/depends.py,sha256=OcLsfTLzMBk_xFV6qsMy_-qFkiphEbbEuaHUooagxg8,730
 fastapi_factory_utilities/core/plugins/odm_plugin/documents.py,sha256=BFQYHxHBmTacJRfhZi2OffvT_RAFvAAiDVQAa_d6Y7w,1141
 fastapi_factory_utilities/core/plugins/odm_plugin/exceptions.py,sha256=acnKJB0lGAzDs-7-LjBap8shjP3iV1a7dw7ouPVF27o,551
-fastapi_factory_utilities/core/plugins/odm_plugin/repositories.py,sha256=5hZ5Cvdqqlnb4NITWlrg_o078B4U0U61MjAXG3VxcH8,8747
+fastapi_factory_utilities/core/plugins/odm_plugin/repositories.py,sha256=r880o--iVj3oK3yTenM5kgJwfFWKSUZa0bfnEwOukFE,8705
 fastapi_factory_utilities/core/plugins/opentelemetry_plugin/__init__.py,sha256=UsXPjiAASn5GIHW8vrF32mklxGNq8ajILV-ty4K1Tbs,4371
-fastapi_factory_utilities/core/plugins/opentelemetry_plugin/builder.py,sha256=ZStlbq7zYtlXXrTloCDmizqxCRu9g2vY5T1oM-AzxLg,10001
-fastapi_factory_utilities/core/plugins/opentelemetry_plugin/configs.py,sha256=4mMa5SrmnPY1R_gVFRtFhi9WNaTGEGZL5iNNhyjcZQ0,3448
+fastapi_factory_utilities/core/plugins/opentelemetry_plugin/builder.py,sha256=9npQImifYAbEg0lFG7KwZ8V78SNrPoaINgd8vKitdMw,12509
+fastapi_factory_utilities/core/plugins/opentelemetry_plugin/configs.py,sha256=pMG9leMB7rtdkdGFLIxXflV7bf9epGrrYPt2N97KZcM,3750
 fastapi_factory_utilities/core/plugins/opentelemetry_plugin/exceptions.py,sha256=CpsHayfQpP0zghN8y5PP6TBy-cXhHoNxBR--I86gAdE,327
 fastapi_factory_utilities/core/plugins/opentelemetry_plugin/helpers.py,sha256=qpTIzX67orJz7vy6SBIwRs24omMBoToJkhpurZRjPuk,1533
 fastapi_factory_utilities/core/protocols.py,sha256=TzZKr_KfmTphk2LL-TD2XzxNlLbihbGM2DxWMhc5lEQ,2428
+fastapi_factory_utilities/core/security/jwt.py,sha256=LuNVmTlONrmoKl7ghNv5JHV4qzMNOwuxJQlWgGSvBoo,5631
+fastapi_factory_utilities/core/security/kratos.py,sha256=o6fkl2KfSFT7W_uDAwlLiVFl53r-neL3LQ45H3VqEIM,2350
+fastapi_factory_utilities/core/services/kratos/__init__.py,sha256=DaC29-Ol0WR5vX56IHLGDXP9UrhISq0Juhg_sJTasw4,368
+fastapi_factory_utilities/core/services/kratos/enums.py,sha256=ULJppowlZbOjdnUIXQyI4_nHmHZoNnv7-M1CYQBYXFY,220
+fastapi_factory_utilities/core/services/kratos/exceptions.py,sha256=xAX01-lQvPpADgcwhB5YWSy1UqAxG38s2rlU9AJBJd8,472
+fastapi_factory_utilities/core/services/kratos/objects.py,sha256=Dq9aEuwgwz21oLqJ4VWxrBB6ASJ7Xp_MEdyA3UbzWVE,956
+fastapi_factory_utilities/core/services/kratos/services.py,sha256=RFKrME6M6omWiHORMBCSyvIG0BsimQaCfnmtsOdFfsg,3158
 fastapi_factory_utilities/core/services/status/__init__.py,sha256=N5H0cCN9ZFu_0YZar4RLdCDEjKMICrIhNtfKgB0LI78,370
 fastapi_factory_utilities/core/services/status/enums.py,sha256=IUxWAd0Ecknri4BqzaqoDRRhT_8LdcgtQcNqgNVDXGE,599
 fastapi_factory_utilities/core/services/status/exceptions.py,sha256=_fQFGqHKnG54Hs-ZtC4gs0xwzSH246_WwQOonraoGKw,856
@@ -64,8 +71,8 @@ fastapi_factory_utilities/example/models/books/repository.py,sha256=7K63uAsSEGZ2
 fastapi_factory_utilities/example/services/books/__init__.py,sha256=Z06yNRoA7Zg3TGN-Q9rrvJg6Bbx-qJw661MVwukV6vQ,148
 fastapi_factory_utilities/example/services/books/services.py,sha256=-x7d4hotUWLzWo5uImMjFmtNcSTHwWv2bfttIbYYKbA,5380
 fastapi_factory_utilities/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastapi_factory_utilities-0.2.11.dist-info/LICENSE,sha256=iO1nLzMMst6vEiqgSUrfrbetM7b0bvdzXhbed5tqG8o,1074
-fastapi_factory_utilities-0.2.11.dist-info/METADATA,sha256=VjUjf7vr94g7d-cmMgWR3yPgnBZHLFqGHmhWoypcwvw,3387
-fastapi_factory_utilities-0.2.11.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-fastapi_factory_utilities-0.2.11.dist-info/entry_points.txt,sha256=IK0VcBexXo4uXQmTrbfhhnnfq4GmXPRn0GBB8hzlsq4,101
-fastapi_factory_utilities-0.2.11.dist-info/RECORD,,
+fastapi_factory_utilities-0.3.0.dist-info/LICENSE,sha256=iO1nLzMMst6vEiqgSUrfrbetM7b0bvdzXhbed5tqG8o,1074
+fastapi_factory_utilities-0.3.0.dist-info/METADATA,sha256=Leqepw4j2B1UqEphj5J1M-w_miwtf0RX7KQql4Q_WN4,3477
+fastapi_factory_utilities-0.3.0.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+fastapi_factory_utilities-0.3.0.dist-info/entry_points.txt,sha256=IK0VcBexXo4uXQmTrbfhhnnfq4GmXPRn0GBB8hzlsq4,101
+fastapi_factory_utilities-0.3.0.dist-info/RECORD,,