fastapi-factory-utilities 0.3.3__py3-none-any.whl → 0.8.2__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

@@ -12,12 +12,12 @@ from .config import (
 from .enums import EnvironmentEnum
 
 __all__: list[str] = [
-    "BaseApplicationConfig",
-    "EnvironmentEnum",
     "ApplicationAbstract",
     "ApplicationGenericBuilder",
-    "RootConfig",
-    "HttpServiceDependencyConfig",
+    "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
@@ -61,10 +72,7 @@ class ApplicationAbstract(ABC):
         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
@@ -74,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:
@@ -105,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."""
@@ -122,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,21 +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:
@@ -42,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:
@@ -57,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.
 
@@ -83,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
@@ -102,8 +84,9 @@ 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
@@ -117,7 +100,8 @@ class ApplicationGenericBuilder(Generic[T]):
         """Build the application and serve it with Uvicorn."""
         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

@@ -82,6 +82,8 @@ 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):

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,7 +1,7 @@
 """FastAPI Factory Utilities exceptions."""
 
 import logging
-from typing import Any, Sequence
+from typing import Any, cast
 
 from opentelemetry.trace import Span, get_current_span
 from opentelemetry.util.types import AttributeValue
@@ -13,39 +13,75 @@ _logger: BoundLogger = get_logger()
 class FastAPIFactoryUtilitiesError(Exception):
     """Base exception for the FastAPI Factory Utilities."""
 
+    FILTERED_ATTRIBUTES: tuple[str, ...] = ()
+    DEFAULT_LOGGING_LEVEL: int = logging.ERROR
+    DEFAULT_MESSAGE: str | None = None
+
     def __init__(
         self,
-        *args: tuple[Any],
-        message: str | None = None,
-        level: int = logging.ERROR,
-        **kwargs: dict[str, Any],
+        *args: object,
+        **kwargs: Any,
     ) -> 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.
+            **kwargs: The keyword arguments.
+
         """
+        # If Default Message is not set, try to extract it from docstring (first line)
+        default_message: str = self.DEFAULT_MESSAGE or "An error occurred"
+        if self.DEFAULT_MESSAGE is None and self.__doc__ is not None:
+            default_message = self.__doc__.split("\n", maxsplit=1)[0]
+        # Extract the message and the level from the kwargs if they are present
+        self.message: str | None = cast(str | None, kwargs.pop("message", None))
+        self.level: int = cast(int, kwargs.pop("level", self.DEFAULT_LOGGING_LEVEL))
+
+        # 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]
+        elif self.message is None:
+            self.message = default_message
+
         # 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)
-            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)
+        if self.message:
+            _logger.log(level=self.level, event=self.message)
+
+        # Set the kwargs as attributes of the exception
+        for key, value in kwargs.items():
+            if key in self.FILTERED_ATTRIBUTES:
+                continue
+            setattr(self, key, value)
+
+        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():
+                    if key in self.FILTERED_ATTRIBUTES:
+                        continue
+                    attribute_value: AttributeValue
+                    if not isinstance(value, (str, bool, int, float)):
+                        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)
+
+    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

fastapi_factory_utilities/core/plugins/aiopika/configs.py

@@ -0,0 +1,85 @@
+"""Provides the configuration for the Aiopika plugin."""
+
+from typing import Annotated, Any, ClassVar
+
+from pydantic import BaseModel, ConfigDict, Field, UrlConstraints
+from pydantic_core import Url, ValidationError
+
+from fastapi_factory_utilities.core.utils.importlib import get_path_file_in_package
+from fastapi_factory_utilities.core.utils.yaml_reader import (
+    UnableToReadYamlFileError,
+    YamlFileReader,
+)
+
+from .exceptions import AiopikaPluginConfigError
+
+
+class AiopikaConfig(BaseModel):
+    """Provides the configuration model for the Aiopika plugin.
+
+    https://docs.aio-pika.com/#aio-pika-connect-robust-function-and-aio-pika-robustconnection-class-specific
+
+    Possible query parameters for the AMQP URL:
+        name (str url encoded) - A string that will be visible in the RabbitMQ management console
+        and in the server logs, convenient for diagnostics.
+        cafile (str) - Path to Certificate Authority file
+        capath (str) - Path to Certificate Authority directory
+        cadata (str url encoded) - URL encoded CA certificate content
+        keyfile (str) - Path to client ssl private key file
+        certfile (str) - Path to client ssl certificate file
+        no_verify_ssl - No verify server SSL certificates. 0 by default and means False other value means True.
+        heartbeat (int-like) - interval in seconds between AMQP heartbeat packets. 0 disables this feature.
+        reconnect_interval (float-like) - is the period in seconds, not more often than the attempts
+        to re-establish the connection will take place.
+        fail_fast (true/yes/y/enable/on/enabled/1 means True, otherwise False) - special behavior
+        for the start connection attempt, if it fails, all other attempts stops
+        and an exception will be thrown at the connection stage. Enabled by default, if you are sure you need
+        to disable this feature, be ensures for the passed URL is really working.
+        Otherwise, your program will go into endless reconnection attempts that can not be successed.
+
+    """
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(frozen=True, extra="forbid")
+
+    amqp_url: Annotated[Url, UrlConstraints(allowed_schemes=["amqp", "amqps"])] = Field(description="The AMQP URL.")
+
+
+def build_config_from_package(package_name: str) -> AiopikaConfig:
+    """Build the configuration from the package.
+
+    Args:
+        package_name (str): The package name.
+
+    Returns:
+        AiopikaConfig: The Aiopika configuration.
+
+    Raises:
+        AiopikaPluginConfigError: If the configuration cannot be read or created or the configuration is invalid.
+    """
+    try:
+        yaml_file_content: dict[str, Any] = YamlFileReader(
+            file_path=get_path_file_in_package(
+                filename="application.yaml",
+                package=package_name,
+            ),
+            yaml_base_key="aiopika",
+            use_environment_injection=True,
+        ).read()
+    except (FileNotFoundError, ImportError, UnableToReadYamlFileError) as exception:
+        raise AiopikaPluginConfigError(
+            message="Unable to read the application configuration file for the Aiopika plugin in the package.",
+            package_name=package_name,
+        ) from exception
+
+    # Create the application configuration model
+    config: AiopikaConfig
+    try:
+        config = AiopikaConfig(**yaml_file_content)
+    except ValidationError as exception:
+        raise AiopikaPluginConfigError(
+            message="Unable to create the application configuration model for the Aiopika plugin in the package.",
+            package_name=package_name,
+            validation_errors=exception.errors(),
+        ) from exception
+
+    return config

fastapi_factory_utilities/core/plugins/aiopika/depends.py

@@ -0,0 +1,20 @@
+"""Provides the dependencies for the Aiopika plugin."""
+
+from typing import cast
+
+from aio_pika.abc import AbstractRobustConnection
+from fastapi import Request
+
+from .exceptions import AiopikaPluginBaseError
+
+DEPENDS_AIOPIKA_ROBUST_CONNECTION_KEY: str = "aiopika_robust_connection"
+
+
+def depends_aiopika_robust_connection(request: Request) -> AbstractRobustConnection:
+    """Get the Aiopika robust connection."""
+    robust_connection: AbstractRobustConnection | None = cast(
+        AbstractRobustConnection | None, getattr(request.app.state, DEPENDS_AIOPIKA_ROBUST_CONNECTION_KEY, None)
+    )
+    if robust_connection is None:
+        raise AiopikaPluginBaseError("Aiopika robust connection not found in the application state.")
+    return robust_connection