fastapi-factory-utilities 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

fastapi_factory_utilities/core/plugins/aiopika/message.py

@@ -0,0 +1,86 @@
+"""Provides the message for the Aiopika plugin."""
+
+from enum import StrEnum, auto
+from typing import ClassVar, Generic, TypeVar
+
+from aio_pika.abc import DeliveryMode, HeadersType
+from aio_pika.message import IncomingMessage, Message
+from pydantic import BaseModel, ConfigDict, Field, PrivateAttr
+
+GenericMessageData = TypeVar("GenericMessageData", bound=BaseModel)
+
+
+class SenderModel(BaseModel):
+    """Sender model."""
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid", frozen=True)
+
+    name: str = Field(description="The name of the sender.")
+
+
+class MessageTypeEnum(StrEnum):
+    """Message type enum."""
+
+    FUNCTIONAL_EVENT = auto()
+
+
+class AbstractMessage(BaseModel, Generic[GenericMessageData]):
+    """Abstract message."""
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra="forbid", frozen=True)
+
+    message_type: MessageTypeEnum = Field(
+        description="The type of the message.", default=MessageTypeEnum.FUNCTIONAL_EVENT
+    )
+    sender: SenderModel = Field(description="The sender of the message.")
+    data: GenericMessageData = Field(description="The data of the message.")
+
+    _incoming_message: IncomingMessage | None = PrivateAttr()
+    _headers: HeadersType = PrivateAttr(default_factory=dict)
+
+    def get_headers(self) -> HeadersType:
+        """Get the headers of the message."""
+        return self._headers
+
+    def set_headers(self, headers: HeadersType) -> None:
+        """Set the headers of the message."""
+        self._headers = headers
+
+    def set_incoming_message(self, incoming_message: IncomingMessage) -> None:
+        """Set the incoming message."""
+        self._incoming_message = incoming_message
+        self.set_headers(headers=incoming_message.headers)
+
+    async def ack(self) -> None:
+        """Ack the message.
+
+        Raises:
+            - ValueError: If the incoming message is not set.
+        """
+        if self._incoming_message is None:
+            raise ValueError("Incoming message is not set.")
+        await self._incoming_message.ack(multiple=False)
+
+    async def reject(self, requeue: bool = True) -> None:
+        """Reject the message.
+
+        Args:
+            requeue (bool): Whether to requeue the message.
+
+        Raises:
+            - ValueError: If the incoming message is not set.
+        """
+        if self._incoming_message is None:
+            raise ValueError("Incoming message is not set.")
+        await self._incoming_message.reject(requeue=requeue)
+
+    def to_aiopika_message(self) -> Message:
+        """Convert the message to an Aiopika message."""
+        return Message(
+            body=self.model_dump_json().encode("utf-8"),
+            headers=self.get_headers(),
+            content_type="application/json",
+            content_encoding="utf-8",
+            delivery_mode=DeliveryMode.PERSISTENT,
+            priority=0,
+        )

fastapi_factory_utilities/core/plugins/aiopika/plugins.py

@@ -0,0 +1,63 @@
+"""Provides the Aiopika plugin."""
+
+from aio_pika import connect_robust
+from aio_pika.abc import AbstractRobustConnection
+from fastapi import Request
+from structlog.stdlib import BoundLogger, get_logger
+
+from fastapi_factory_utilities.core.plugins.abstracts import PluginAbstract
+
+from .configs import AiopikaConfig, build_config_from_package
+
+_logger: BoundLogger = get_logger(__package__)
+
+
+class AiopikaPlugin(PluginAbstract):
+    """Aiopika plugin."""
+
+    def __init__(self, aiopika_config: AiopikaConfig | None = None) -> None:
+        """Initialize the Aiopika plugin."""
+        super().__init__()
+        self._aiopika_config: AiopikaConfig | None = aiopika_config
+        self._robust_connection: AbstractRobustConnection | None = None
+
+    @property
+    def robust_connection(self) -> AbstractRobustConnection:
+        """Get the robust connection."""
+        assert self._robust_connection is not None
+        return self._robust_connection
+
+    def on_load(self) -> None:
+        """On load."""
+        assert self._application is not None
+
+        # Build the configuration if not provided
+        if self._aiopika_config is None:
+            self._aiopika_config = build_config_from_package(package_name=self._application.PACKAGE_NAME)
+
+    async def on_startup(self) -> None:
+        """On startup."""
+        assert self._application is not None
+        assert self._aiopika_config is not None
+
+        self._robust_connection = await connect_robust(url=str(self._aiopika_config.amqp_url))
+        self._add_to_state(key="robust_connection", value=self._robust_connection)
+        _logger.debug("Aiopika plugin connected to the AMQP server.", amqp_url=self._aiopika_config.amqp_url)
+
+    async def on_shutdown(self) -> None:
+        """On shutdown."""
+        if self._robust_connection is not None:
+            await self._robust_connection.close()
+        _logger.debug("Aiopika plugin shutdown.")
+
+
+def depends_robust_connection(request: Request) -> AbstractRobustConnection:
+    """Depends on the robust connection.
+
+    Args:
+        request (Request): The request.
+
+    Returns:
+        AbstractRobustConnection: The robust connection.
+    """
+    return request.app.state.robust_connection

fastapi_factory_utilities/core/plugins/aiopika/publisher/__init__.py

@@ -0,0 +1,7 @@
+"""Provides the publisher ports for the Aiopika plugin."""
+
+from .abstract import AbstractPublisher
+
+__all__: list[str] = [
+    "AbstractPublisher",
+]

fastapi_factory_utilities/core/plugins/aiopika/publisher/abstract.py

@@ -0,0 +1,66 @@
+"""Provides the abstract class for the publisher port for the Aiopika plugin."""
+
+from typing import Any, ClassVar, Generic, Self, TypeVar
+
+from aio_pika.abc import TimeoutType
+from aio_pika.message import Message
+from aiormq.abc import ConfirmationFrameType, DeliveredMessage
+from pamqp.commands import Basic
+
+from ..abstract import AbstractAiopikaResource
+from ..exceptions import AiopikaPluginBaseError
+from ..exchange import Exchange
+from ..message import AbstractMessage
+
+GenericMessage = TypeVar("GenericMessage", bound=AbstractMessage[Any])
+
+
+class AbstractPublisher(AbstractAiopikaResource, Generic[GenericMessage]):
+    """Abstract class for the publisher port for the Aiopika plugin."""
+
+    DEFAULT_OPERATION_TIMEOUT: ClassVar[TimeoutType] = 10.0
+
+    def __init__(self, exchange: Exchange, name: str | None = None) -> None:
+        """Initialize the publisher port."""
+        super().__init__()
+        self._name: str = name or self.__class__.__name__
+        self._exchange: Exchange = exchange
+
+    async def setup(self) -> Self:
+        """Setup the publisher."""
+        await super().setup()
+        await self._exchange.setup()
+        return self
+
+    async def publish(self, message: GenericMessage, routing_key: str) -> None:
+        """Publish a message."""
+        # Transform the message to an Aiopika message
+        aiopika_message: Message
+        try:
+            aiopika_message = message.to_aiopika_message()
+        except Exception as exception:
+            raise AiopikaPluginBaseError(
+                message="Failed to convert the message to an Aiopika message.",
+            ) from exception
+        # Publish the message
+        confirmation: ConfirmationFrameType | DeliveredMessage | None
+        try:
+            confirmation = await self._exchange.exchange.publish(  # pyright: ignore
+                message=aiopika_message,
+                routing_key=routing_key,
+                mandatory=True,
+                timeout=self.DEFAULT_OPERATION_TIMEOUT,
+            )
+        except Exception as exception:
+            raise AiopikaPluginBaseError(
+                message="Failed to publish the message.",
+            ) from exception
+
+        if confirmation is None:
+            raise AiopikaPluginBaseError(
+                message="Failed to publish the message.",
+            )
+        if isinstance(confirmation, Basic.Return):
+            raise AiopikaPluginBaseError(
+                message="Failed to publish the message.",
+            )

fastapi_factory_utilities/core/plugins/aiopika/queue.py

@@ -0,0 +1,86 @@
+"""Provides the queue for the Aiopika plugin."""
+
+from typing import ClassVar, Self
+
+from aio_pika.abc import AbstractQueue, TimeoutType
+
+from .abstract import AbstractAiopikaResource
+from .exceptions import AiopikaPluginBaseError, AiopikaPluginQueueNotDeclaredError
+from .exchange import Exchange
+
+
+class Queue(AbstractAiopikaResource):
+    """Queue."""
+
+    DEFAULT_OPERATION_TIMEOUT: ClassVar[TimeoutType] = 10.0
+
+    def __init__(  # pylint: disable=too-many-arguments # noqa: PLR0913
+        self,
+        name: str,
+        exchange: Exchange,
+        routing_key: str,
+        durable: bool = True,
+        auto_delete: bool = False,
+        exclusive: bool = True,
+        timeout: TimeoutType = DEFAULT_OPERATION_TIMEOUT,
+    ) -> None:
+        """Initialize the queue."""
+        super().__init__()
+        # Initialize the queue properties
+        self._name: str = name
+        self._routing_key: str = routing_key
+        self._durable: bool = durable
+        self._auto_delete: bool = auto_delete
+        self._exclusive: bool = exclusive
+        self._timeout: TimeoutType = timeout
+        # Behavior properties
+        self._exchange: Exchange = exchange
+        self._queue: AbstractQueue | None = None
+
+    @property
+    def queue(self) -> AbstractQueue:
+        """Get the Aiopika queue."""
+        if self._queue is None:
+            raise AiopikaPluginQueueNotDeclaredError(
+                message="Queue not declared.",
+                queue=self._name,
+            )
+        return self._queue
+
+    async def _declare(self) -> Self:
+        """Declare the queue."""
+        try:
+            self._queue = await self._channel.declare_queue(  # pyright: ignore
+                name=self._name,
+                durable=self._durable,
+                auto_delete=self._auto_delete,
+                exclusive=self._exclusive,
+                timeout=self._timeout,
+            )
+        except Exception as exception:
+            raise AiopikaPluginBaseError(
+                message="Failed to declare the queue.",
+            ) from exception
+        return self
+
+    async def _bind(self) -> Self:
+        """Bind the queue to the exchange."""
+        try:
+            await self._queue.bind(  # pyright: ignore
+                exchange=self._exchange.exchange,
+                routing_key=self._routing_key,
+                timeout=self._timeout,
+            )
+        except Exception as exception:
+            raise AiopikaPluginBaseError(
+                message="Failed to bind the queue to the exchange.",
+            ) from exception
+        return self
+
+    async def setup(self) -> Self:
+        """Setup the queue."""
+        await super().setup()
+        if self._queue is None:
+            await self._declare()
+        await self._bind()
+        return self

fastapi_factory_utilities/core/plugins/odm_plugin/__init__.py

@@ -1,168 +1,23 @@
-"""Oriented Data Model (ODM) plugin package."""
+"""ODM Plugin Module."""
 
-from logging import INFO, Logger, getLogger
-from typing import Any
-
-from beanie import init_beanie  # pyright: ignore[reportUnknownVariableType]
-from motor.motor_asyncio import AsyncIOMotorClient
-from reactivex import Subject
-from structlog.stdlib import BoundLogger, get_logger
-
-from fastapi_factory_utilities.core.plugins import PluginState
-from fastapi_factory_utilities.core.protocols import ApplicationAbstractProtocol
-from fastapi_factory_utilities.core.services.status.enums import (
-    ComponentTypeEnum,
-    HealthStatusEnum,
-    ReadinessStatusEnum,
-)
-from fastapi_factory_utilities.core.services.status.services import StatusService
-from fastapi_factory_utilities.core.services.status.types import (
-    ComponentInstanceType,
-    Status,
-)
-
-from .builder import ODMBuilder
 from .depends import depends_odm_client, depends_odm_database
 from .documents import BaseDocument
-from .exceptions import OperationError, UnableToCreateEntityDueToDuplicateKeyError
+from .exceptions import (
+    ODMPluginBaseException,
+    ODMPluginConfigError,
+    OperationError,
+    UnableToCreateEntityDueToDuplicateKeyError,
+)
 from .helpers import PersistedEntity
+from .plugins import ODMPlugin
 from .repositories import AbstractRepository
 
-_logger: BoundLogger = get_logger()
-
-
-def pre_conditions_check(application: ApplicationAbstractProtocol) -> bool:
-    """Check the pre-conditions for the OpenTelemetry plugin.
-
-    Args:
-        application (BaseApplicationProtocol): The application.
-
-    Returns:
-        bool: True if the pre-conditions are met, False otherwise.
-    """
-    del application
-    return True
-
-
-def on_load(
-    application: ApplicationAbstractProtocol,
-) -> list["PluginState"] | None:
-    """Actions to perform on load for the OpenTelemetry plugin.
-
-    Args:
-        application (BaseApplicationProtocol): The application.
-    """
-    del application
-    # Configure the pymongo logger to INFO level
-    pymongo_logger: Logger = getLogger("pymongo")
-    pymongo_logger.setLevel(INFO)
-    _logger.debug("ODM plugin loaded.")
-
-
-async def on_startup(
-    application: ApplicationAbstractProtocol,
-) -> list["PluginState"] | None:
-    """Actions to perform on startup for the ODM plugin.
-
-    Args:
-        application (BaseApplicationProtocol): The application.
-        odm_config (ODMConfig): The ODM configuration.
-
-    Returns:
-        None
-    """
-    states: list[PluginState] = []
-
-    status_service: StatusService = application.get_status_service()
-    component_instance: ComponentInstanceType = ComponentInstanceType(
-        component_type=ComponentTypeEnum.DATABASE, identifier="MongoDB"
-    )
-    monitoring_subject: Subject[Status] = status_service.register_component_instance(
-        component_instance=component_instance
-    )
-
-    try:
-        odm_factory: ODMBuilder = ODMBuilder(application=application).build_all()
-        await odm_factory.wait_ping()
-    except Exception as exception:  # pylint: disable=broad-except
-        _logger.error(f"ODM plugin failed to start. {exception}")
-        # TODO: Report the error to the status_service
-        # this will report the application as unhealthy
-        monitoring_subject.on_next(
-            value=Status(health=HealthStatusEnum.UNHEALTHY, readiness=ReadinessStatusEnum.NOT_READY)
-        )
-        return states
-
-    if odm_factory.odm_database is None or odm_factory.odm_client is None:
-        _logger.error(
-            f"ODM plugin failed to start. Database: {odm_factory.odm_database} - Client: {odm_factory.odm_client}"
-        )
-        # TODO: Report the error to the status_service
-        # this will report the application as unhealthy
-        monitoring_subject.on_next(
-            value=Status(health=HealthStatusEnum.UNHEALTHY, readiness=ReadinessStatusEnum.NOT_READY)
-        )
-        return states
-
-    # Add the ODM client and database to the application state
-    states.append(
-        PluginState(key="odm_client", value=odm_factory.odm_client),
-    )
-    states.append(
-        PluginState(
-            key="odm_database",
-            value=odm_factory.odm_database,
-        ),
-    )
-
-    # TODO: Find a better way to initialize beanie with the document models of the concrete application
-    # through an hook in the application, a dynamis import ?
-    try:
-        await init_beanie(
-            database=odm_factory.odm_database,
-            document_models=application.ODM_DOCUMENT_MODELS,
-        )
-    except Exception as exception:  # pylint: disable=broad-except
-        _logger.error(f"ODM plugin failed to start. {exception}")
-        # TODO: Report the error to the status_service
-        # this will report the application as unhealthy
-        monitoring_subject.on_next(
-            value=Status(health=HealthStatusEnum.UNHEALTHY, readiness=ReadinessStatusEnum.NOT_READY)
-        )
-        return states
-
-    _logger.info(
-        f"ODM plugin started. Database: {odm_factory.odm_database.name} - "
-        f"Client: {odm_factory.odm_client.address} - "
-        f"Document models: {application.ODM_DOCUMENT_MODELS}"
-    )
-
-    monitoring_subject.on_next(value=Status(health=HealthStatusEnum.HEALTHY, readiness=ReadinessStatusEnum.READY))
-
-    return states
-
-
-async def on_shutdown(application: ApplicationAbstractProtocol) -> None:
-    """Actions to perform on shutdown for the ODM plugin.
-
-    Args:
-        application (BaseApplicationProtocol): The application.
-
-    Returns:
-        None
-    """
-    # Skip if the ODM plugin was not started correctly
-    if not hasattr(application.get_asgi_app().state, "odm_client"):
-        return
-
-    client: AsyncIOMotorClient[Any] = application.get_asgi_app().state.odm_client
-    client.close()
-    _logger.debug("ODM plugin shutdown.")
-
-
 __all__: list[str] = [
     "AbstractRepository",
     "BaseDocument",
+    "ODMPlugin",
+    "ODMPluginBaseException",
+    "ODMPluginConfigError",
     "OperationError",
     "PersistedEntity",
     "UnableToCreateEntityDueToDuplicateKeyError",

fastapi_factory_utilities/core/plugins/odm_plugin/builder.py

@@ -242,7 +242,7 @@ class ODMBuilder:
 
         return self
 
-    async def wait_ping(self):
+    async def wait_ping(self) -> None:
         """Wait for the ODM client to be ready.
 
         Returns:

fastapi_factory_utilities/core/plugins/odm_plugin/configs.py

@@ -12,4 +12,4 @@ class ODMConfig(BaseModel):
 
     database: str = "test"
 
-    connection_timeout_ms: int = 1000
+    connection_timeout_ms: int = 4000

fastapi_factory_utilities/core/plugins/odm_plugin/documents.py

@@ -13,7 +13,7 @@ class BaseDocument(Document):
     """Base document class."""
 
     # To be agnostic of MongoDN, we use UUID as the document ID.
-    id: UUID = Field(  # pyright: ignore[reportIncompatibleVariableOverride]
+    id: UUID = Field(  # type: ignore
         default_factory=uuid4, description="The document ID."
     )
 

fastapi_factory_utilities/core/plugins/odm_plugin/plugins.py

@@ -0,0 +1,155 @@
+"""Oriented Data Model (ODM) plugin package."""
+
+from logging import INFO, Logger, getLogger
+from typing import Any, Self
+
+from beanie import Document, init_beanie  # pyright: ignore[reportUnknownVariableType]
+from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorDatabase
+from reactivex import Subject
+from structlog.stdlib import BoundLogger, get_logger
+
+from fastapi_factory_utilities.core.plugins.abstracts import PluginAbstract
+from fastapi_factory_utilities.core.protocols import ApplicationAbstractProtocol
+from fastapi_factory_utilities.core.services.status.enums import (
+    ComponentTypeEnum,
+    HealthStatusEnum,
+    ReadinessStatusEnum,
+)
+from fastapi_factory_utilities.core.services.status.services import StatusService
+from fastapi_factory_utilities.core.services.status.types import (
+    ComponentInstanceType,
+    Status,
+)
+
+from .builder import ODMBuilder
+from .configs import ODMConfig
+from .depends import depends_odm_client, depends_odm_database
+from .documents import BaseDocument
+from .exceptions import OperationError, UnableToCreateEntityDueToDuplicateKeyError
+from .helpers import PersistedEntity
+from .repositories import AbstractRepository
+
+_logger: BoundLogger = get_logger()
+
+
+class ODMPlugin(PluginAbstract):
+    """ODM plugin."""
+
+    def __init__(
+        self, document_models: list[type[Document]] | None = None, odm_config: ODMConfig | None = None
+    ) -> None:
+        """Initialize the ODM plugin."""
+        super().__init__()
+        self._component_instance: ComponentInstanceType | None = None
+        self._monitoring_subject: Subject[Status] | None = None
+        self._document_models: list[type[Document]] | None = document_models
+        self._odm_config: ODMConfig | None = odm_config
+        self._odm_client: AsyncIOMotorClient[Any] | None = None
+        self._odm_database: AsyncIOMotorDatabase[Any] | None = None
+
+    def set_application(self, application: ApplicationAbstractProtocol) -> Self:
+        """Set the application."""
+        self._document_models = self._document_models or application.ODM_DOCUMENT_MODELS
+        return super().set_application(application)
+
+    def on_load(self) -> None:
+        """Actions to perform on load for the ODM plugin."""
+        # Configure the pymongo logger to INFO level
+
+        pymongo_logger: Logger = getLogger("pymongo")
+        pymongo_logger.setLevel(INFO)
+        _logger.debug("ODM plugin loaded.")
+
+    def _setup_status(self) -> None:
+        assert self._application is not None
+        status_service: StatusService = self._application.get_status_service()
+        self._component_instance = ComponentInstanceType(
+            component_type=ComponentTypeEnum.DATABASE, identifier="MongoDB"
+        )
+        self._monitoring_subject = status_service.register_component_instance(
+            component_instance=self._component_instance
+        )
+
+    async def _setup_beanie(self) -> None:
+        assert self._application is not None
+        assert self._odm_database is not None
+        assert self._document_models is not None
+        assert self._monitoring_subject is not None
+        # TODO: Find a better way to initialize beanie with the document models of the concrete application
+        # through an hook in the application, a dynamis import ?
+        try:
+            await init_beanie(
+                database=self._odm_database,
+                document_models=self._document_models,
+            )
+        except Exception as exception:  # pylint: disable=broad-except
+            _logger.error(f"ODM plugin failed to start. {exception}")
+            # TODO: Report the error to the status_service
+            # this will report the application as unhealthy
+            self._monitoring_subject.on_next(
+                value=Status(health=HealthStatusEnum.UNHEALTHY, readiness=ReadinessStatusEnum.NOT_READY)
+            )
+
+    async def on_startup(self) -> None:
+        """Actions to perform on startup for the ODM plugin."""
+        assert self._application is not None
+        self._setup_status()
+        assert self._monitoring_subject is not None
+        assert self._component_instance is not None
+
+        try:
+            odm_factory: ODMBuilder = ODMBuilder(application=self._application, odm_config=self._odm_config).build_all()
+            await odm_factory.wait_ping()
+            self._odm_database = odm_factory.odm_database
+            self._odm_client = odm_factory.odm_client
+        except Exception as exception:  # pylint: disable=broad-except
+            _logger.error(f"ODM plugin failed to start. {exception}")
+            # TODO: Report the error to the status_service
+            # this will report the application as unhealthy
+            self._monitoring_subject.on_next(
+                value=Status(health=HealthStatusEnum.UNHEALTHY, readiness=ReadinessStatusEnum.NOT_READY)
+            )
+            return None
+
+        if self._odm_database is None or self._odm_client is None:
+            _logger.error(
+                f"ODM plugin failed to start. Database: {odm_factory.odm_database} - Client: {odm_factory.odm_client}"
+            )
+            # TODO: Report the error to the status_service
+            # this will report the application as unhealthy
+            self._monitoring_subject.on_next(
+                value=Status(health=HealthStatusEnum.UNHEALTHY, readiness=ReadinessStatusEnum.NOT_READY)
+            )
+            return None
+
+        self._add_to_state(key="odm_client", value=odm_factory.odm_client)
+        self._add_to_state(key="odm_database", value=odm_factory.odm_database)
+
+        await self._setup_beanie()
+
+        _logger.info(
+            f"ODM plugin started. Database: {self._odm_database.name} - "
+            f"Client: {self._odm_client.address} - "
+            f"Document models: {self._application.ODM_DOCUMENT_MODELS}"
+        )
+
+        self._monitoring_subject.on_next(
+            value=Status(health=HealthStatusEnum.HEALTHY, readiness=ReadinessStatusEnum.READY)
+        )
+
+    async def on_shutdown(self) -> None:
+        """Actions to perform on shutdown for the ODM plugin."""
+        if self._odm_client is not None:
+            self._odm_client.close()
+        _logger.debug("ODM plugin shutdown.")
+
+
+__all__: list[str] = [
+    "AbstractRepository",
+    "BaseDocument",
+    "OperationError",
+    "PersistedEntity",
+    "UnableToCreateEntityDueToDuplicateKeyError",
+    "depends_odm_client",
+    "depends_odm_database",
+]