fastapi-factory-utilities 0.2.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

fastapi_factory_utilities/core/api/__init__.py

@@ -22,4 +22,4 @@ api_v2: APIRouter = APIRouter(prefix="/v2")
 api.include_router(router=api_v1)
 api.include_router(router=api_v2)
 
-__all__: list[str] = ["api", "TagEnum"]
+__all__: list[str] = ["TagEnum", "api"]

fastapi_factory_utilities/core/api/v1/sys/health.py

@@ -10,10 +10,10 @@ from pydantic import BaseModel
 
 from fastapi_factory_utilities.core.services.status.enums import HealthStatusEnum
 from fastapi_factory_utilities.core.services.status.services import (
-    ComponentInstanceKey,
     StatusService,
     depends_status_service,
 )
+from fastapi_factory_utilities.core.services.status.types import ComponentInstanceKey
 
 api_v1_sys_health = APIRouter(prefix="/health")
 

fastapi_factory_utilities/core/app/__init__.py

@@ -2,13 +2,22 @@
 
 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] = [
-    "BaseApplicationConfig",
-    "EnvironmentEnum",
     "ApplicationAbstract",
     "ApplicationGenericBuilder",
+    "BaseApplicationConfig",
+    "DependencyConfig",
+    "EnvironmentEnum",
+    "HttpServiceDependencyConfig",
     "RootConfig",
+    "depends_dependency_config",
 ]

fastapi_factory_utilities/core/app/application.py

@@ -12,10 +12,7 @@ from structlog.stdlib import BoundLogger, get_logger
 from fastapi_factory_utilities.core.api import api
 from fastapi_factory_utilities.core.app.config import RootConfig
 from fastapi_factory_utilities.core.app.fastapi_builder import FastAPIBuilder
-from fastapi_factory_utilities.core.app.plugin_manager.plugin_manager import (
-    PluginManager,
-)
-from fastapi_factory_utilities.core.plugins import PluginsEnum
+from fastapi_factory_utilities.core.plugins import PluginAbstract
 from fastapi_factory_utilities.core.services.status.services import StatusService
 
 _logger: BoundLogger = get_logger(__name__)
@@ -31,12 +28,10 @@ class ApplicationAbstract(ABC):
     # TODO: Find a way to remove this from here
     ODM_DOCUMENT_MODELS: ClassVar[list[type[Document]]]
 
-    DEFAULT_PLUGINS_ACTIVATED: ClassVar[list[PluginsEnum]] = []
-
     def __init__(
         self,
         root_config: RootConfig,
-        plugin_manager: PluginManager,
+        plugins: list[PluginAbstract],
         fastapi_builder: FastAPIBuilder,
     ) -> None:
         """Instantiate the application."""
@@ -44,9 +39,25 @@ class ApplicationAbstract(ABC):
         self.fastapi_builder: FastAPIBuilder = fastapi_builder
         # Add the API router to the FastAPI application
         self.fastapi_builder.add_api_router(router=api, without_resource_path=True)
-        self.plugin_manager: PluginManager = plugin_manager
+        self.plugins: list[PluginAbstract] = plugins
         self._add_to_state: dict[str, Any] = {}
 
+    def load_plugins(self) -> None:
+        """Load the plugins."""
+        for plugin in self.plugins:
+            plugin.set_application(application=self)
+            plugin.on_load()
+
+    async def startup_plugins(self) -> None:
+        """Startup the plugins."""
+        for plugin in self.plugins:
+            await plugin.on_startup()
+
+    async def shutdown_plugins(self) -> None:
+        """Shutdown the plugins."""
+        for plugin in self.plugins:
+            await plugin.on_shutdown()
+
     def setup(self) -> None:
         """Initialize the application."""
         # Initialize FastAPI application
@@ -54,15 +65,14 @@ class ApplicationAbstract(ABC):
         # Status service
         self.status_service: StatusService = StatusService()
         self.add_to_state(key="status_service", value=self.status_service)
+        self.add_to_state(key="config", value=self.config)
+        self.add_to_state(key="application", value=self)
         self._apply_states_to_fastapi_app()
         # Configure the application
         self.configure()
         self._apply_states_to_fastapi_app()
         # Initialize PluginManager
-        self.plugin_manager.add_application_context(application=self)
-        self.plugin_manager.load()
-        # Add the states to the FastAPI app
-        self._import_states_from_plugin_manager()
+        self.load_plugins()
 
     def _apply_states_to_fastapi_app(self) -> None:
         # Add manually added states to the FastAPI app
@@ -72,13 +82,6 @@ class ApplicationAbstract(ABC):
             setattr(self._asgi_app.state, key, value)
         self._add_to_state.clear()
 
-    def _import_states_from_plugin_manager(self) -> None:
-        """Import the states from the plugins."""
-        for state in self.plugin_manager.states:
-            self.add_to_state(key=state.key, value=state.value)
-        self.plugin_manager.clear_states()
-        self._apply_states_to_fastapi_app()
-
     def add_to_state(self, key: str, value: Any) -> None:
         """Add a value to the FastAPI app state."""
         if key in self._add_to_state:
@@ -103,14 +106,13 @@ class ApplicationAbstract(ABC):
     @asynccontextmanager
     async def fastapi_lifespan(self, fastapi: FastAPI) -> AsyncGenerator[None, None]:  # pylint: disable=unused-argument
         """FastAPI lifespan context manager."""
-        await self.plugin_manager.trigger_startup()
-        self._import_states_from_plugin_manager()
+        await self.startup_plugins()
         await self.on_startup()
         try:
             yield
         finally:
             await self.on_shutdown()
-            await self.plugin_manager.trigger_shutdown()
+            await self.shutdown_plugins()
 
     def get_config(self) -> RootConfig:
         """Get the configuration."""
@@ -120,10 +122,6 @@ class ApplicationAbstract(ABC):
         """Get the ASGI application."""
         return self._asgi_app
 
-    def get_plugin_manager(self) -> PluginManager:
-        """Get the plugin manager."""
-        return self.plugin_manager
-
     def get_status_service(self) -> StatusService:
         """Get the status service."""
         return self.status_service

fastapi_factory_utilities/core/app/builder.py

@@ -4,10 +4,7 @@ from typing import Any, Generic, Self, TypeVar, get_args
 
 from fastapi_factory_utilities.core.app.config import GenericConfigBuilder, RootConfig
 from fastapi_factory_utilities.core.app.fastapi_builder import FastAPIBuilder
-from fastapi_factory_utilities.core.app.plugin_manager.plugin_manager import (
-    PluginManager,
-)
-from fastapi_factory_utilities.core.plugins import PluginsEnum
+from fastapi_factory_utilities.core.plugins import PluginAbstract
 from fastapi_factory_utilities.core.utils.log import LogModeEnum, setup_log
 from fastapi_factory_utilities.core.utils.uvicorn import UvicornUtils
 
@@ -19,20 +16,16 @@ T = TypeVar("T", bound=ApplicationAbstract)
 class ApplicationGenericBuilder(Generic[T]):
     """Application generic builder."""
 
-    def __init__(self, plugins_activation_list: list[PluginsEnum] | None = None) -> None:
+    def __init__(self, plugins: list[PluginAbstract] | None = None) -> None:
         """Instanciate the ApplicationGenericBuilder."""
+        self._uvicorn_utils: UvicornUtils | None = None
         self._root_config: RootConfig | None = None
-        self._plugin_manager: PluginManager | None = None
+        self._plugins: list[PluginAbstract] = plugins or []
         self._fastapi_builder: FastAPIBuilder | None = None
         generic_args: tuple[Any, ...] = get_args(self.__orig_bases__[0])  # type: ignore
         self._application_class: type[T] = generic_args[0]
-        self._plugins_activation_list: list[PluginsEnum]
-        if plugins_activation_list is None:
-            self._plugins_activation_list = self._application_class.DEFAULT_PLUGINS_ACTIVATED
-        else:
-            self._plugins_activation_list = plugins_activation_list
 
-    def add_plugin_to_activate(self, plugin: PluginsEnum) -> Self:
+    def add_plugin_to_activate(self, plugin: PluginAbstract) -> Self:
         """Add a plugin to activate.
 
         Args:
@@ -41,7 +34,7 @@ class ApplicationGenericBuilder(Generic[T]):
         Returns:
             Self: The builder.
         """
-        self._plugins_activation_list.append(plugin)
+        self._plugins.append(plugin)
         return self
 
     def add_config(self, config: RootConfig) -> Self:
@@ -56,18 +49,6 @@ class ApplicationGenericBuilder(Generic[T]):
         self._root_config = config
         return self
 
-    def add_plugin_manager(self, plugin_manager: PluginManager) -> Self:
-        """Add the plugin manager to the builder.
-
-        Args:
-            plugin_manager (PluginManager): The plugin manager.
-
-        Returns:
-            Self: The builder.
-        """
-        self._plugin_manager = plugin_manager
-        return self
-
     def add_fastapi_builder(self, fastapi_builder: FastAPIBuilder) -> Self:
         """Add the FastAPI builder to the builder.
 
@@ -82,18 +63,20 @@ class ApplicationGenericBuilder(Generic[T]):
 
     def _build_from_package_root_config(self) -> RootConfig:
         """Build the configuration from the package."""
-        return GenericConfigBuilder[self._application_class.CONFIG_CLASS](
+        return GenericConfigBuilder[self._application_class.CONFIG_CLASS](  # type: ignore
             package_name=self._application_class.PACKAGE_NAME,
             config_class=self._application_class.CONFIG_CLASS,
         ).build()
 
-    def build(self) -> T:
-        """Build the application."""
-        # Plugin manager
-        if self._plugin_manager is None:
-            self._plugin_manager = PluginManager()
-        for plugin in self._plugins_activation_list:
-            self._plugin_manager.activate(plugin=plugin)
+    def build(self, **kwargs: Any) -> T:
+        """Build the application.
+
+        Args:
+            **kwargs: The keyword arguments to pass to the application.
+
+        Returns:
+            T: The application.
+        """
         # RootConfig
         self._root_config = self._root_config or self._build_from_package_root_config()
         # FastAPIBuilder
@@ -101,21 +84,24 @@ class ApplicationGenericBuilder(Generic[T]):
 
         application: T = self._application_class(
             root_config=self._root_config,
-            plugin_manager=self._plugin_manager,
+            plugins=self._plugins,
             fastapi_builder=self._fastapi_builder,
+            **kwargs,
         )
         application.setup()
         return application
 
     def build_as_uvicorn_utils(self) -> UvicornUtils:
         """Build the application and provide UvicornUtils."""
-        return UvicornUtils(app=self.build())
+        self._uvicorn_utils = UvicornUtils(app=self.build())
+        return self._uvicorn_utils
 
     def build_and_serve(self) -> None:
         """Build the application and serve it with Uvicorn."""
-        uvicorn_utils: UvicornUtils = self.build_as_uvicorn_utils()
+        uvicorn_utils: UvicornUtils = self._uvicorn_utils or self.build_as_uvicorn_utils()
 
-        setup_log(mode=LogModeEnum.CONSOLE)
+        assert self._root_config is not None
+        setup_log(mode=LogModeEnum.CONSOLE, logging_config=self._root_config.logging)
 
         try:
             uvicorn_utils.serve()

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,20 @@ 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")
+    hydra_admin: HttpServiceDependencyConfig | None = Field(default=None, description="Hydra admin dependency config")
+    hydra_public: HttpServiceDependencyConfig | None = Field(default=None, description="Hydra public dependency config")
+
+
 class RootConfig(BaseModel):
     """Root configuration."""
 
@@ -84,6 +99,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 +178,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/app/fastapi_builder.py

@@ -64,7 +64,7 @@ class FastAPIBuilder:
             title=self._root_config.application.service_name,
             description="",
             version=self._root_config.application.version,
-            lifespan=lifespan,  # type: ignore
+            lifespan=lifespan,
         )
 
         fastapi.add_middleware(
@@ -77,7 +77,8 @@ class FastAPIBuilder:
 
         for middleware_args in self._middleware_list:
             fastapi.add_middleware(
-                middleware_class=middleware_args.middleware_class, **middleware_args.kwargs  # type: ignore
+                middleware_class=middleware_args.middleware_class,  # type: ignore
+                **middleware_args.kwargs,  # pyright: ignore
             )
 
         fastapi.include_router(router=self._base_router)

fastapi_factory_utilities/core/exceptions.py

@@ -1,43 +1,79 @@
 """FastAPI Factory Utilities exceptions."""
 
 import logging
-from typing import Any
+from collections.abc import Sequence
+from typing import NotRequired, TypedDict, Unpack
 
 from opentelemetry.trace import Span, get_current_span
+from opentelemetry.util.types import AttributeValue
 from structlog.stdlib import BoundLogger, get_logger
 
 _logger: BoundLogger = get_logger()
 
 
+class ExceptionParameters(TypedDict):
+    """Parameters for the exception."""
+
+    message: NotRequired[str]
+    level: NotRequired[int]
+
+
 class FastAPIFactoryUtilitiesError(Exception):
     """Base exception for the FastAPI Factory Utilities."""
 
     def __init__(
         self,
-        *args: tuple[Any],
-        message: str | None = None,
-        level: int = logging.ERROR,
-        **kwargs: dict[str, Any],
+        *args: object,
+        **kwargs: Unpack[ExceptionParameters],
     ) -> None:
-        """Instanciate the exception.
+        """Instantiate the exception.
 
         Args:
-            *args (Tuple[Any]): The arguments.
-            message (str | None): The message.
-            level (int): The logging level.
-            **kwargs (dict[str, Any]): The keyword arguments
+            *args: The arguments.
+            message: The message.
+            level: The logging level.
+            **kwargs: The keyword arguments.
+
         """
+        # Extract the message and the level from the kwargs if they are present
+        self.message: str | None = kwargs.pop("message", None)
+        self.level: int = kwargs.pop("level", logging.ERROR)
+
+        # If the message is not present, try to extract it from the args
+        if self.message is None and len(args) > 0 and isinstance(args[0], str):
+            self.message = args[0]
+
         # Log the Exception
-        if message:
-            _logger.log(level=level, event=message)
-            self.message = message
-            self.level = level
-            args = (message, *args)  # type: ignore
-        # Propagate the exception
-        span: Span = get_current_span()
-        # If not otel is setup, INVALID_SPAN is retrive from get_current_span
-        # and it will respond False to the is_recording method
-        if span.is_recording():
-            span.record_exception(self)
+        if self.message:
+            _logger.log(level=self.level, event=self.message)
+
+        try:
+            # Propagate the exception
+            span: Span = get_current_span()
+            # If not otel is setup, INVALID_SPAN is retrieved from get_current_span
+            # and it will respond False to the is_recording method
+            if span.is_recording():
+                span.record_exception(self)
+                for key, value in kwargs.items():
+                    attribute_value: AttributeValue
+                    if not isinstance(value, (str, bool, int, float, Sequence)):
+                        attribute_value = str(value)
+                    else:
+                        attribute_value = value
+                    span.set_attribute(key, attribute_value)
+        except Exception:  # pylint: disable=broad-exception-caught
+            # Suppress any errors that occur while propagating the exception
+            pass
+
         # Call the parent class
-        super().__init__(*args, **kwargs)
+        super().__init__(*args)
+
+    def __str__(self) -> str:
+        """Return the string representation of the exception.
+
+        Returns:
+            str: The message if available, otherwise the default exception string.
+        """
+        if self.message is not None:
+            return self.message
+        return super().__str__()

fastapi_factory_utilities/core/plugins/__init__.py

@@ -1,36 +1,7 @@
 """Package for plugins."""
 
-from enum import StrEnum, auto
-from typing import Any
-
-
-class PluginsEnum(StrEnum):
-    """Enumeration for the plugins."""
-
-    OPENTELEMETRY_PLUGIN = auto()
-    ODM_PLUGIN = auto()
-    HTTPX_PLUGIN = auto()
-
-
-class PluginState:
-    """PluginState represent the state a plugin which to be share to the application and other plugins."""
-
-    def __init__(self, key: str, value: Any) -> None:
-        """Initialize the PluginState."""
-        self._key: str = key
-        self._value = value
-
-    @property
-    def key(self) -> str:
-        """Get the key."""
-        return self._key
-
-    @property
-    def value(self) -> Any:
-        """Get the value."""
-        return self._value
-
+from .abstracts import PluginAbstract
 
 __all__: list[str] = [
-    "PluginsEnum",
+    "PluginAbstract",
 ]

fastapi_factory_utilities/core/plugins/abstracts.py

@@ -0,0 +1,40 @@
+"""Abstracts for the plugins."""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Self
+
+if TYPE_CHECKING:
+    from fastapi_factory_utilities.core.protocols import ApplicationAbstractProtocol
+
+
+class PluginAbstract(ABC):
+    """Abstract class for the plugins."""
+
+    def __init__(self) -> None:
+        """Initialize the plugin."""
+        self._application: ApplicationAbstractProtocol | None = None
+
+    def set_application(self, application: "ApplicationAbstractProtocol") -> Self:
+        """Set the application."""
+        self._application = application
+        return self
+
+    def _add_to_state(self, key: str, value: Any) -> None:
+        """Add to the state."""
+        assert self._application is not None
+        setattr(self._application.get_asgi_app().state, key, value)
+
+    @abstractmethod
+    def on_load(self) -> None:
+        """On load."""
+        raise NotImplementedError
+
+    @abstractmethod
+    async def on_startup(self) -> None:
+        """On startup."""
+        raise NotImplementedError
+
+    @abstractmethod
+    async def on_shutdown(self) -> None:
+        """On shutdown."""
+        raise NotImplementedError

fastapi_factory_utilities/core/plugins/aiopika/__init__.py

@@ -0,0 +1,25 @@
+"""Aiopika Plugin Module."""
+
+from .configs import AiopikaConfig
+from .depends import depends_aiopika_robust_connection
+from .exceptions import AiopikaPluginBaseError, AiopikaPluginConfigError
+from .exchange import Exchange
+from .listener import AbstractListener
+from .message import AbstractMessage, SenderModel
+from .plugins import AiopikaPlugin
+from .publisher import AbstractPublisher
+from .queue import Queue
+
+__all__: list[str] = [
+    "AbstractListener",
+    "AbstractMessage",
+    "AbstractPublisher",
+    "AiopikaConfig",
+    "AiopikaPlugin",
+    "AiopikaPluginBaseError",
+    "AiopikaPluginConfigError",
+    "Exchange",
+    "Queue",
+    "SenderModel",
+    "depends_aiopika_robust_connection",
+]

fastapi_factory_utilities/core/plugins/aiopika/abstract.py

@@ -0,0 +1,48 @@
+"""Provides the abstract class for the Aiopika plugin."""
+
+from abc import ABC
+from typing import Self
+
+from aio_pika.abc import AbstractChannel, AbstractRobustConnection
+
+from .exceptions import AiopikaPluginBaseError, AiopikaPluginConnectionNotProvidedError
+
+
+class AbstractAiopikaResource(ABC):
+    """Abstract class for the Aiopika resource."""
+
+    def __init__(self) -> None:
+        """Initialize the Aiopika resource."""
+        self._robust_connection: AbstractRobustConnection | None = None
+        self._channel: AbstractChannel | None = None
+
+    def set_robust_connection(self, robust_connection: AbstractRobustConnection) -> Self:
+        """Set the robust connection."""
+        self._robust_connection = robust_connection
+        return self
+
+    def set_channel(self, channel: AbstractChannel) -> Self:
+        """Set the channel."""
+        self._channel = channel
+        return self
+
+    async def _acquire_channel(self) -> AbstractChannel:
+        """Acquire the channel."""
+        if self._robust_connection is None:
+            raise AiopikaPluginConnectionNotProvidedError(
+                message="Robust connection not provided.",
+            )
+        if self._channel is None:
+            try:
+                self._channel = await self._robust_connection.channel()
+            except Exception as exception:
+                raise AiopikaPluginBaseError(
+                    message="Failed to acquire the channel.",
+                ) from exception
+        return self._channel
+
+    async def setup(self) -> Self:
+        """Setup the Aiopika resource."""
+        if self._channel is None:
+            await self._acquire_channel()
+        return self