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

fastapi_factory_utilities/core/plugins/odm_plugin/builder.py

@@ -1,13 +1,12 @@
 """Provides the module for the ODM plugin."""
 
-import asyncio
 import time
-from typing import Any, Self
+from typing import Any, ClassVar, Self
 
 from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorDatabase
 from structlog.stdlib import get_logger
 
-from fastapi_factory_utilities.core.protocols import BaseApplicationProtocol
+from fastapi_factory_utilities.core.protocols import ApplicationAbstractProtocol
 from fastapi_factory_utilities.core.utils.importlib import get_path_file_in_package
 from fastapi_factory_utilities.core.utils.yaml_reader import (
     UnableToReadYamlFileError,
@@ -38,9 +37,12 @@ class ODMBuilder:
 
     """
 
+    MS_TO_S: ClassVar[int] = 1000
+    SLEEP_TIME_S: ClassVar[float] = 0.001
+
     def __init__(
         self,
-        application: BaseApplicationProtocol,
+        application: ApplicationAbstractProtocol,
         odm_config: ODMConfig | None = None,
         odm_client: AsyncIOMotorClient[Any] | None = None,
         odm_database: AsyncIOMotorDatabase[Any] | None = None,
@@ -54,7 +56,7 @@ class ODMBuilder:
             odm_database (AsyncIOMotorDatabase): The ODM database for injection. (Default is None)
 
         """
-        self._application: BaseApplicationProtocol = application
+        self._application: ApplicationAbstractProtocol = application
         self._config: ODMConfig | None = odm_config
         self._odm_client: AsyncIOMotorClient[Any] | None = odm_client
         self._odm_database: AsyncIOMotorDatabase[Any] | None = odm_database
@@ -123,40 +125,30 @@ class ODMBuilder:
         return self
 
     @classmethod
-    def _wait_client_to_be_ready(cls, client: AsyncIOMotorClient[Any], timeout_ms: int) -> None:
+    def _wait_client_to_be_ready(cls, client: AsyncIOMotorClient[Any], timeout_s: int) -> None:
         """Wait for the ODM client to be ready.
 
         Args:
             client (AsyncIOMotorClient): The ODM client.
-            timeout_ms (int): The timeout in milliseconds.
+            timeout_s (int): The timeout in seconds.
 
         Raises:
-            ODMPluginConfigError: If the ODM client is not ready.
+            TimeoutError: If the ODM client is not ready in the given timeout.
         """
-        start_timer = time.monotonic()
-
-        async def is_connected(client: AsyncIOMotorClient[Any]) -> bool:
-            """Check if the client is connected."""
-            try:
-                await client.admin.command(
-                    command="ping",
-                )  # pyright: ignore
-                return True
-            except Exception:  # pylint: disable=broad-except
-                _logger.debug("ODM client is not ready.")
-                return False
-
-        loop: asyncio.AbstractEventLoop = asyncio.get_event_loop()
-
-        while not loop.run_in_executor(None, asyncio.Task(is_connected(client))) and (  # type: ignore
-            (time.monotonic() - start_timer) < timeout_ms
-        ):
-            if time.monotonic() - start_timer > timeout_ms:
-                raise ODMPluginConfigError("ODM client is not ready.")
-            time.sleep(0.01)
-
-        if not loop.run_in_executor(None, asyncio.Task(is_connected(client))):  # type: ignore
-            raise ODMPluginConfigError("ODM client is not ready.")
+        start_time: float = time.time()
+        message_time: float = time.time()
+        while (time.time() - start_time) < (timeout_s):
+            if len(client.nodes) > 0:  # type: ignore
+                _logger.info(f"Waiting {(time.time() - start_time)*cls.MS_TO_S}ms for the ODM client to be ready.")
+                return
+
+            if (time.time() - message_time) > 1:
+                elaps_time: float = time.time() - start_time
+                _logger.debug(f"Waiting for the ODM client to be ready. (from {int(elaps_time)}s) ")
+                message_time = time.time()
+            time.sleep(cls.SLEEP_TIME_S)
+
+        raise TimeoutError("The ODM client is not ready in the given timeout.")
 
     def build_client(
         self,
@@ -181,11 +173,11 @@ class ODMBuilder:
         self._odm_client = AsyncIOMotorClient(
             host=self._config.uri,
             connect=True,
-            connectTimeoutMS=self._config.connection_timeout_ms,
-            serverSelectionTimeoutMS=self._config.connection_timeout_ms,
+            connectTimeoutMS=self._config.connection_timeout_s,
+            serverSelectionTimeoutMS=self._config.connection_timeout_s,
         )
 
-        self._wait_client_to_be_ready(client=self._odm_client, timeout_ms=self._config.connection_timeout_ms)
+        self._wait_client_to_be_ready(client=self._odm_client, timeout_s=self._config.connection_timeout_s)
 
         return self
 

fastapi_factory_utilities/core/plugins/odm_plugin/configs.py

@@ -2,8 +2,6 @@
 
 from pydantic import BaseModel, ConfigDict
 
-S_TO_MS = 1000
-
 
 class ODMConfig(BaseModel):
     """Provides the configuration model for the ODM plugin."""
@@ -14,4 +12,4 @@ class ODMConfig(BaseModel):
 
     database: str = "test"
 
-    connection_timeout_ms: int = 1 * S_TO_MS
+    connection_timeout_s: int = 10

fastapi_factory_utilities/core/plugins/odm_plugin/depends.py

@@ -0,0 +1,30 @@
+"""Provide FastAPI dependency for ODM."""
+
+from typing import Any
+
+from fastapi import Request
+from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorDatabase
+
+
+def depends_odm_client(request: Request) -> AsyncIOMotorClient[Any]:
+    """Acquire the ODM client from the request.
+
+    Args:
+        request (Request): The request.
+
+    Returns:
+        AsyncIOMotorClient: The ODM client.
+    """
+    return request.app.state.odm_client
+
+
+def depends_odm_database(request: Request) -> AsyncIOMotorDatabase[Any]:
+    """Acquire the ODM database from the request.
+
+    Args:
+        request (Request): The request.
+
+    Returns:
+        AsyncIOMotorClient: The ODM database.
+    """
+    return request.app.state.odm_database

fastapi_factory_utilities/core/plugins/opentelemetry_plugin/__init__.py

@@ -10,7 +10,7 @@ from opentelemetry.sdk.metrics import MeterProvider
 from opentelemetry.sdk.trace import TracerProvider
 from structlog.stdlib import BoundLogger, get_logger
 
-from fastapi_factory_utilities.core.protocols import BaseApplicationProtocol
+from fastapi_factory_utilities.core.protocols import ApplicationAbstractProtocol
 
 from .builder import OpenTelemetryPluginBuilder
 from .configs import OpenTelemetryConfig
@@ -26,7 +26,7 @@ __all__: list[str] = [
 _logger: BoundLogger = get_logger()
 
 
-def pre_conditions_check(application: BaseApplicationProtocol) -> bool:
+def pre_conditions_check(application: ApplicationAbstractProtocol) -> bool:
     """Check the pre-conditions for the OpenTelemetry plugin.
 
     Args:
@@ -40,7 +40,7 @@ def pre_conditions_check(application: BaseApplicationProtocol) -> bool:
 
 
 def on_load(
-    application: BaseApplicationProtocol,
+    application: ApplicationAbstractProtocol,
 ) -> None:
     """Actions to perform on load for the OpenTelemetry plugin.
 
@@ -71,7 +71,7 @@ def on_load(
 
 
 async def on_startup(
-    application: BaseApplicationProtocol,
+    application: ApplicationAbstractProtocol,
 ) -> None:
     """Actions to perform on startup for the OpenTelemetry plugin.
 
@@ -85,7 +85,7 @@ async def on_startup(
     _logger.debug("OpenTelemetry plugin started.")
 
 
-async def on_shutdown(application: BaseApplicationProtocol) -> None:
+async def on_shutdown(application: ApplicationAbstractProtocol) -> None:
     """Actions to perform on shutdown for the OpenTelemetry plugin.
 
     Args:

fastapi_factory_utilities/core/plugins/opentelemetry_plugin/builder.py

@@ -24,7 +24,7 @@ from fastapi_factory_utilities.core.plugins.opentelemetry_plugin.configs import
     OpenTelemetryMeterConfig,
     OpenTelemetryTracerConfig,
 )
-from fastapi_factory_utilities.core.protocols import BaseApplicationProtocol
+from fastapi_factory_utilities.core.protocols import ApplicationAbstractProtocol
 from fastapi_factory_utilities.core.utils.importlib import get_path_file_in_package
 from fastapi_factory_utilities.core.utils.yaml_reader import (
     UnableToReadYamlFileError,
@@ -38,13 +38,13 @@ from .exceptions import OpenTelemetryPluginConfigError
 class OpenTelemetryPluginBuilder:
     """Configure the injection bindings for OpenTelemetryPlugin."""
 
-    def __init__(self, application: BaseApplicationProtocol) -> None:
+    def __init__(self, application: ApplicationAbstractProtocol) -> None:
         """Instantiate the OpenTelemetryPluginFactory.
 
         Args:
             application (BaseApplicationProtocol): The application object.
         """
-        self._application: BaseApplicationProtocol = application
+        self._application: ApplicationAbstractProtocol = application
         self._resource: Resource | None = None
         self._config: OpenTelemetryConfig | None = None
         self._meter_provider: MeterProvider | None = None
@@ -94,10 +94,10 @@ class OpenTelemetryPluginBuilder:
         """
         self._resource = Resource(
             attributes={
-                DEPLOYMENT_ENVIRONMENT: self._application.get_config().environment.value,
-                SERVICE_NAME: self._application.get_config().service_name,
-                SERVICE_NAMESPACE: self._application.get_config().service_namespace,
-                SERVICE_VERSION: self._application.get_config().version,
+                DEPLOYMENT_ENVIRONMENT: self._application.get_config().application.environment.value,
+                SERVICE_NAME: self._application.get_config().application.service_name,
+                SERVICE_NAMESPACE: self._application.get_config().application.service_namespace,
+                SERVICE_VERSION: self._application.get_config().application.version,
             }
         )
         return self

fastapi_factory_utilities/core/protocols.py

@@ -6,39 +6,42 @@ from typing import TYPE_CHECKING, ClassVar, Protocol, runtime_checkable
 from beanie import Document
 from fastapi import FastAPI
 
+from fastapi_factory_utilities.core.plugins import PluginsEnum
+from fastapi_factory_utilities.core.services.status.services import StatusService
+
 if TYPE_CHECKING:
-    from fastapi_factory_utilities.core.app.base.config_abstract import (
-        AppConfigAbstract,
-    )
+    from fastapi_factory_utilities.core.app.config import RootConfig
+    from fastapi_factory_utilities.core.plugins import PluginState
 
 
-class BaseApplicationProtocol(Protocol):
+class ApplicationAbstractProtocol(Protocol):
     """Protocol for the base application."""
 
-    PACKAGE_NAME: str
+    PACKAGE_NAME: ClassVar[str]
 
     ODM_DOCUMENT_MODELS: ClassVar[list[type[Document]]]
 
+    DEFAULT_PLUGINS_ACTIVATED: ClassVar[list[PluginsEnum]]
+
     @abstractmethod
-    def get_config(self) -> "AppConfigAbstract":
+    def get_config(self) -> "RootConfig":
         """Get the application configuration."""
 
     @abstractmethod
     def get_asgi_app(self) -> FastAPI:
         """Get the ASGI application."""
 
+    @abstractmethod
+    def get_status_service(self) -> StatusService:
+        """Get the status service."""
+
 
 @runtime_checkable
 class PluginProtocol(Protocol):
-    """Defines the protocol for the plugin.
-
-    Attributes:
-        INJECTOR_MODULE (type[Module]): The module for the plugin.
-
-    """
+    """Defines the protocol for the plugins."""
 
     @abstractmethod
-    def pre_conditions_check(self, application: BaseApplicationProtocol) -> bool:
+    def pre_conditions_check(self, application: ApplicationAbstractProtocol) -> bool:
         """Check the pre-conditions for the plugin.
 
         Args:
@@ -49,7 +52,7 @@ class PluginProtocol(Protocol):
         """
 
     @abstractmethod
-    def on_load(self, application: BaseApplicationProtocol) -> None:
+    def on_load(self, application: ApplicationAbstractProtocol) -> list["PluginState"] | None:
         """The actions to perform on load for the plugin.
 
         Args:
@@ -60,7 +63,7 @@ class PluginProtocol(Protocol):
         """
 
     @abstractmethod
-    async def on_startup(self, application: BaseApplicationProtocol) -> None:
+    async def on_startup(self, application: ApplicationAbstractProtocol) -> list["PluginState"] | None:
         """The actions to perform on startup for the plugin.
 
         Args:
@@ -71,7 +74,7 @@ class PluginProtocol(Protocol):
         """
 
     @abstractmethod
-    async def on_shutdown(self, application: BaseApplicationProtocol) -> None:
+    async def on_shutdown(self, application: ApplicationAbstractProtocol) -> None:
         """The actions to perform on shutdown for the plugin.
 
         Args:

fastapi_factory_utilities/core/services/status/__init__.py

@@ -0,0 +1,14 @@
+"""Package covering the StatusService."""
+
+from .enums import ComponentTypeEnum, HealthStatusEnum, ReadinessStatusEnum
+from .services import StatusService
+from .types import ComponentInstanceType, Status
+
+__all__: list[str] = [
+    "ComponentTypeEnum",
+    "ComponentInstanceType",
+    "HealthStatusEnum",
+    "ReadinessStatusEnum",
+    "StatusService",
+    "Status",
+]

fastapi_factory_utilities/core/services/status/enums.py

@@ -0,0 +1,30 @@
+"""Provides the status enums for the service."""
+
+from enum import StrEnum
+
+
+class HealthStatusEnum(StrEnum):
+    """Health status enum."""
+
+    HEALTHY = "healthy"
+    UNHEALTHY = "unhealthy"
+
+
+class ReadinessStatusEnum(StrEnum):
+    """Readiness status enum."""
+
+    READY = "ready"
+    NOT_READY = "not_ready"
+
+
+class ComponentTypeEnum(StrEnum):
+    """Component type enum."""
+
+    SERVICE = "service"
+    DATABASE = "database"
+    CACHE = "cache"
+    STORAGE = "storage"
+    MESSAGE_BROKER = "message_broker"
+    SEARCH_ENGINE = "search_engine"
+    TASK_QUEUE = "task_queue"
+    OTHER = "other"

fastapi_factory_utilities/core/services/status/exceptions.py

@@ -0,0 +1,27 @@
+"""Provides exceptions for the status service."""
+
+from fastapi_factory_utilities.core.exceptions import FastAPIFactoryUtilitiesError
+from fastapi_factory_utilities.core.services.status.types import ComponentInstanceType
+
+
+class StatusServiceError(FastAPIFactoryUtilitiesError):
+    """Status service error."""
+
+
+class ComponentRegistrationError(StatusServiceError):
+    """Component registration error."""
+
+    def __init__(
+        self,
+        component_instance: ComponentInstanceType,
+    ) -> None:
+        """Initialize the component registration error.
+
+        Args:
+            component_instance (ComponentInstanceType): The component instance.
+
+        """
+        super().__init__(
+            message="An error occurred while registering the component instance.",
+            component_instance=component_instance,  # type: ignore
+        )

fastapi_factory_utilities/core/services/status/health_calculator_strategies.py

@@ -0,0 +1,48 @@
+"""Health calculator strategies."""
+
+from typing import Protocol, runtime_checkable
+
+from .enums import HealthStatusEnum
+from .types import ComponentInstanceKey, Status
+
+
+@runtime_checkable
+class HealthCalculatorStrategy(Protocol):
+    """Health calculator strategy."""
+
+    def __init__(self, components_status: dict[ComponentInstanceKey, Status]) -> None:
+        """Initialize the health calculator.
+
+        Args:
+            components_status (dict[str, Status]): The components status.
+        """
+        raise NotImplementedError
+
+    def calculate(self) -> HealthStatusEnum:
+        """Calculate the health status."""
+        raise NotImplementedError
+
+
+class HealthSimpleCalculatorStrategy:
+    """Health calculator.
+
+    This class calculates the health status based on the components status.
+    It's a simple implementation that returns unhealthy if at least one component is unhealthy for now.
+    We want to enhance this class to support more complex health calculation in the future.
+    ( )
+    """
+
+    def __init__(self, components_status: dict[ComponentInstanceKey, Status]) -> None:
+        """Initialize the health calculator.
+
+        Args:
+            components_status (dict[str, Status]): The components status.
+        """
+        self._components_status: dict[ComponentInstanceKey, Status] = components_status
+
+    def calculate(self) -> HealthStatusEnum:
+        """Calculate the health status."""
+        for status in self._components_status.values():
+            if status["health"] != HealthStatusEnum.HEALTHY:
+                return HealthStatusEnum.UNHEALTHY
+        return HealthStatusEnum.HEALTHY

fastapi_factory_utilities/core/services/status/readiness_calculator_strategies.py

@@ -0,0 +1,41 @@
+"""Readiness calculator strategies."""
+
+from typing import Protocol
+
+from .enums import ReadinessStatusEnum
+from .types import ComponentInstanceKey, Status
+
+
+class ReadinessCalculatorStrategy(Protocol):
+    """Readiness calculator strategy."""
+
+    def __init__(self, components_status: dict[ComponentInstanceKey, Status]) -> None:
+        """Initialize the readiness calculator.
+
+        Args:
+            components_status (dict[str, Status]): The components status.
+        """
+        raise NotImplementedError
+
+    def calculate(self) -> ReadinessStatusEnum:
+        """Calculate the readiness status."""
+        raise NotImplementedError
+
+
+class ReadinessSimpleCalculatorStrategy:
+    """Readiness calculator."""
+
+    def __init__(self, components_status: dict[ComponentInstanceKey, Status]) -> None:
+        """Initialize the readiness calculator.
+
+        Args:
+            components_status (dict[str, Status]): The components status.
+        """
+        self._components_status: dict[ComponentInstanceKey, Status] = components_status
+
+    def calculate(self) -> ReadinessStatusEnum:
+        """Calculate the readiness status."""
+        for status in self._components_status.values():
+            if status["readiness"] != ReadinessStatusEnum.READY:
+                return ReadinessStatusEnum.NOT_READY
+        return ReadinessStatusEnum.READY