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

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

@@ -3,20 +3,19 @@
 Provide the Get health endpoint
 """
 
-from enum import StrEnum
 from http import HTTPStatus
 
-from fastapi import APIRouter, Response
+from fastapi import APIRouter, Depends, Response
 from pydantic import BaseModel
 
-api_v1_sys_health = APIRouter(prefix="/health")
-
-
-class HealthStatusEnum(StrEnum):
-    """Health status enum."""
+from fastapi_factory_utilities.core.services.status.enums import HealthStatusEnum
+from fastapi_factory_utilities.core.services.status.services import (
+    ComponentInstanceKey,
+    StatusService,
+    depends_status_service,
+)
 
-    HEALTHY = "healthy"
-    UNHEALTHY = "unhealthy"
+api_v1_sys_health = APIRouter(prefix="/health")
 
 
 class HealthResponseModel(BaseModel):
@@ -40,14 +39,59 @@ class HealthResponseModel(BaseModel):
         },
     },
 )
-def get_api_v1_sys_health(response: Response) -> HealthResponseModel:
+def get_api_v1_sys_health(
+    response: Response, status_service: StatusService = Depends(depends_status_service)
+) -> HealthResponseModel:
     """Get the health of the system.
 
     Args:
         response (Response): The response object.
+        status_service (StatusService): The status service.
 
     Returns:
         HealthResponse: The health status.
     """
-    response.status_code = HTTPStatus.OK
-    return HealthResponseModel(status=HealthStatusEnum.HEALTHY)
+    status: HealthStatusEnum = status_service.get_status()["health"]
+    match status:
+        case HealthStatusEnum.HEALTHY:
+            response.status_code = HTTPStatus.OK.value
+        case HealthStatusEnum.UNHEALTHY:
+            response.status_code = HTTPStatus.INTERNAL_SERVER_ERROR.value
+    return HealthResponseModel(status=status)
+
+
+class ComponentHealthResponseModel(BaseModel):
+    """Component health response schema."""
+
+    components: dict[ComponentInstanceKey, HealthStatusEnum]
+
+
+@api_v1_sys_health.get(
+    path="/components",
+    tags=["sys"],
+    response_model=ComponentHealthResponseModel,
+    responses={
+        HTTPStatus.OK.value: {
+            "model": ComponentHealthResponseModel,
+            "description": "Health status of all components.",
+        },
+    },
+)
+def get_api_v1_sys_components_health(
+    status_service: StatusService = Depends(depends_status_service),
+) -> ComponentHealthResponseModel:
+    """Get the health of all components.
+
+    Args:
+        status_service (StatusService): The status service.
+
+    Returns:
+        list[ComponentHealthResponseModel]: The health status of all components.
+    """
+    components_dict: dict[ComponentInstanceKey, HealthStatusEnum] = {}
+
+    for _, components in status_service.get_components_status_by_type().items():
+        for key, status in components.items():
+            components_dict[key] = status["health"]
+
+    return ComponentHealthResponseModel(components=dict(components_dict))

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

@@ -3,20 +3,18 @@
 Provide the Get readiness endpoint
 """
 
-from enum import StrEnum
 from http import HTTPStatus
 
-from fastapi import APIRouter, Response
+from fastapi import APIRouter, Depends, Response
 from pydantic import BaseModel
 
-api_v1_sys_readiness = APIRouter(prefix="/readiness")
-
-
-class ReadinessStatusEnum(StrEnum):
-    """Readiness status enum."""
+from fastapi_factory_utilities.core.services.status.enums import ReadinessStatusEnum
+from fastapi_factory_utilities.core.services.status.services import (
+    StatusService,
+    depends_status_service,
+)
 
-    READY = "ready"
-    NOT_READY = "not_ready"
+api_v1_sys_readiness = APIRouter(prefix="/readiness")
 
 
 class ReadinessResponseModel(BaseModel):
@@ -40,14 +38,23 @@ class ReadinessResponseModel(BaseModel):
         },
     },
 )
-def get_api_v1_sys_readiness(response: Response) -> ReadinessResponseModel:
+def get_api_v1_sys_readiness(
+    response: Response, status_service: StatusService = Depends(depends_status_service)
+) -> ReadinessResponseModel:
     """Get the readiness of the system.
 
     Args:
         response (Response): The response object.
+        status_service (StatusService): The status service
 
     Returns:
         ReadinessResponse: The readiness status.
     """
-    response.status_code = HTTPStatus.OK
-    return ReadinessResponseModel(status=ReadinessStatusEnum.READY)
+    status: ReadinessStatusEnum = status_service.get_status()["readiness"]
+
+    match status:
+        case ReadinessStatusEnum.READY:
+            response.status_code = HTTPStatus.OK.value
+        case ReadinessStatusEnum.NOT_READY:
+            response.status_code = HTTPStatus.INTERNAL_SERVER_ERROR.value
+    return ReadinessResponseModel(status=status)

fastapi_factory_utilities/core/app/__init__.py

@@ -1,19 +1,14 @@
 """Provides the core application module for the Python Factory."""
 
-from .base import (
-    AppConfigAbstract,
-    ApplicationConfigFactoryException,
-    ApplicationFactoryException,
-    BaseApplication,
-    BaseApplicationException,
-)
+from .application import ApplicationAbstract
+from .builder import ApplicationGenericBuilder
+from .config import BaseApplicationConfig, RootConfig
 from .enums import EnvironmentEnum
 
 __all__: list[str] = [
-    "BaseApplication",
-    "AppConfigAbstract",
+    "BaseApplicationConfig",
     "EnvironmentEnum",
-    "ApplicationConfigFactoryException",
-    "ApplicationFactoryException",
-    "BaseApplicationException",
+    "ApplicationAbstract",
+    "ApplicationGenericBuilder",
+    "RootConfig",
 ]

fastapi_factory_utilities/core/app/application.py

@@ -0,0 +1,133 @@
+"""Provides the ApplicationAbstract class."""
+
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from typing import Any, ClassVar
+
+from beanie import Document
+from fastapi import FastAPI
+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.services.status.services import StatusService
+
+_logger: BoundLogger = get_logger(__name__)
+
+
+class ApplicationAbstract(ABC):
+    """Application abstract class."""
+
+    PACKAGE_NAME: ClassVar[str]
+
+    CONFIG_CLASS: ClassVar[type[RootConfig]] = RootConfig
+
+    # 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,
+        fastapi_builder: FastAPIBuilder,
+    ) -> None:
+        """Instantiate the application."""
+        self.config: RootConfig = root_config
+        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._add_to_state: dict[str, Any] = {}
+
+    def setup(self) -> None:
+        """Initialize the application."""
+        # Initialize FastAPI application
+        self._asgi_app: FastAPI = self.fastapi_builder.build(lifespan=self.fastapi_lifespan)
+        # Status service
+        self.status_service: StatusService = StatusService()
+        self.add_to_state(key="status_service", value=self.status_service)
+        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()
+
+    def _apply_states_to_fastapi_app(self) -> None:
+        # Add manually added states to the FastAPI app
+        for key, value in self._add_to_state.items():
+            if hasattr(self._asgi_app.state, key):
+                _logger.warn(f"Key {key} already exists in the state. Don't set it outside of the application.")
+            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:
+            raise ValueError(f"Key {key} already exists in the state.")
+        self._add_to_state[key] = value
+
+    @abstractmethod
+    def configure(self) -> None:
+        """Configure the application."""
+        raise NotImplementedError
+
+    @abstractmethod
+    async def on_startup(self) -> None:
+        """Startup the application."""
+        raise NotImplementedError
+
+    @abstractmethod
+    async def on_shutdown(self) -> None:
+        """Shutdown the application."""
+        raise NotImplementedError
+
+    @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.on_startup()
+        try:
+            yield
+        finally:
+            await self.on_shutdown()
+            await self.plugin_manager.trigger_shutdown()
+
+    def get_config(self) -> RootConfig:
+        """Get the configuration."""
+        return self.config
+
+    def get_asgi_app(self) -> FastAPI:
+        """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
+
+    async def __call__(self, scope: Any, receive: Any, send: Any) -> None:
+        """Forward the call to the FastAPI app."""
+        return await self._asgi_app.__call__(scope=scope, receive=receive, send=send)

fastapi_factory_utilities/core/app/builder.py

@@ -0,0 +1,123 @@
+"""Provide the ApplicationGenericBuilder class."""
+
+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.utils.log import LogModeEnum, setup_log
+from fastapi_factory_utilities.core.utils.uvicorn import UvicornUtils
+
+from .application import ApplicationAbstract
+
+T = TypeVar("T", bound=ApplicationAbstract)
+
+
+class ApplicationGenericBuilder(Generic[T]):
+    """Application generic builder."""
+
+    def __init__(self, plugins_activation_list: list[PluginsEnum] | None = None) -> None:
+        """Instanciate the ApplicationGenericBuilder."""
+        self._root_config: RootConfig | None = None
+        self._plugin_manager: PluginManager | None = None
+        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:
+        """Add a plugin to activate.
+
+        Args:
+            plugin (PluginsEnum): The plugin to activate.
+
+        Returns:
+            Self: The builder.
+        """
+        self._plugins_activation_list.append(plugin)
+        return self
+
+    def add_config(self, config: RootConfig) -> Self:
+        """Add the configuration to the builder.
+
+        Args:
+            config (RootConfig): The configuration.
+
+        Returns:
+            Self: The builder.
+        """
+        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.
+
+        Args:
+            fastapi_builder (FastAPIBuilder): The FastAPI builder.
+
+        Returns:
+            Self: The builder.
+        """
+        self._fastapi_builder = fastapi_builder
+        return self
+
+    def _build_from_package_root_config(self) -> RootConfig:
+        """Build the configuration from the package."""
+        return GenericConfigBuilder[self._application_class.CONFIG_CLASS](
+            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)
+        # RootConfig
+        self._root_config = self._root_config or self._build_from_package_root_config()
+        # FastAPIBuilder
+        self._fastapi_builder = self._fastapi_builder or FastAPIBuilder(root_config=self._root_config)
+
+        application: T = self._application_class(
+            root_config=self._root_config,
+            plugin_manager=self._plugin_manager,
+            fastapi_builder=self._fastapi_builder,
+        )
+        application.setup()
+        return application
+
+    def build_as_uvicorn_utils(self) -> UvicornUtils:
+        """Build the application and provide UvicornUtils."""
+        return UvicornUtils(app=self.build())
+
+    def build_and_serve(self) -> None:
+        """Build the application and serve it with Uvicorn."""
+        uvicorn_utils: UvicornUtils = self.build_as_uvicorn_utils()
+
+        setup_log(mode=LogModeEnum.CONSOLE)
+
+        try:
+            uvicorn_utils.serve()
+        except KeyboardInterrupt:
+            pass

fastapi_factory_utilities/core/app/config.py

@@ -0,0 +1,164 @@
+"""Provide the configuration for the app server."""
+
+from typing import Any, ClassVar, Generic, TypeVar, get_args
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from fastapi_factory_utilities.core.app.exceptions import ConfigBuilderError
+from fastapi_factory_utilities.core.utils.configs import (
+    UnableToReadConfigFileError,
+    ValueErrorConfigError,
+    build_config_from_file_in_package,
+)
+from fastapi_factory_utilities.core.utils.log import LoggingConfig
+
+from .enums import EnvironmentEnum
+
+
+def default_allow_all() -> list[str]:
+    """Default allow all."""
+    return ["*"]
+
+
+class CorsConfig(BaseModel):
+    """CORS configuration."""
+
+    allow_origins: list[str] = Field(default_factory=default_allow_all, description="Allowed origins")
+    allow_credentials: bool = Field(default=True, description="Allow credentials")
+    allow_methods: list[str] = Field(default_factory=default_allow_all, description="Allowed methods")
+    allow_headers: list[str] = Field(default_factory=default_allow_all, description="Allowed headers")
+    expose_headers: list[str] = Field(default_factory=list, description="Exposed headers")
+    max_age: int = Field(default=600, description="Max age")
+
+
+class ServerConfig(BaseModel):
+    """Server configuration."""
+
+    # Pydantic configuration
+    model_config: ClassVar[ConfigDict] = ConfigDict(frozen=True, extra="forbid")
+
+    # Server configuration mainly used by uvicorn
+    host: str = Field(default="0.0.0.0", description="Server host")
+    port: int = Field(default=8000, description="Server port")
+    workers: int = Field(default=1, description="Number of workers")
+
+
+class DevelopmentConfig(BaseModel):
+    """Development configuration."""
+
+    # Pydantic configuration
+    model_config: ClassVar[ConfigDict] = ConfigDict(frozen=True, extra="forbid")
+
+    # Development configuration
+    debug: bool = Field(default=False, description="Debug mode")
+    reload: bool = Field(default=False, description="Reload mode")
+
+
+class BaseApplicationConfig(BaseModel):
+    """Application configuration abstract class."""
+
+    # Pydantic configuration
+    model_config: ClassVar[ConfigDict] = ConfigDict(frozen=True, extra="forbid")
+
+    # Application configuration
+    # (mainly used for monitoring and information reporting)
+    service_namespace: str = Field(description="Service namespace")
+    environment: EnvironmentEnum = Field(description="Deployed environment")
+    service_name: str = Field(description="Service name")
+    description: str = Field(description="Service description")
+    version: str = Field(description="Service version")
+    # Root path for the application
+    root_path: str = Field(default="", description="Root path")
+
+
+class RootConfig(BaseModel):
+    """Root configuration."""
+
+    # Pydantic configuration
+    # extra = Extra.ignore, to be able to add extra categories for your application purposes
+    model_config: ClassVar[ConfigDict] = ConfigDict(frozen=True, extra="ignore")
+
+    # Root configuration with all sub configurations
+    application: BaseApplicationConfig = Field(description="Application configuration")
+    server: ServerConfig = Field(description="Server configuration", default_factory=ServerConfig)
+    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)
+
+
+GenericConfig = TypeVar("GenericConfig", bound=BaseModel)
+
+
+class GenericConfigBuilder(Generic[GenericConfig]):
+    """Application configuration builder.
+
+    This class is used to build the application configuration from a YAML file.
+    It can be used to build any configuration model
+    """
+
+    DEFAULT_FILENAME: str = "application.yaml"
+    DEFAULT_YAML_BASE_KEY: str | None = None
+
+    def __init__(
+        self,
+        package_name: str,
+        config_class: type[GenericConfig] | None = None,
+        filename: str = DEFAULT_FILENAME,
+        yaml_base_key: str | None = DEFAULT_YAML_BASE_KEY,
+    ) -> None:
+        """Instantiate the builder.
+
+        Args:
+            package_name (str): The package name.
+            config_class (Type[AppConfigAbstract]): The configuration class.
+            filename (str, optional): The filename. Defaults to DEFAULT_FILENAME.
+            yaml_base_key (str, optional): The YAML base key. Defaults to DEFAULT_YAML_BASE_KEY.
+
+        TODO: prevent the double definition of config_class and through the generic type
+        """
+        self.package_name: str = package_name
+        generic_args: tuple[Any, ...] = get_args(self.__orig_bases__[0])  # type: ignore
+
+        self.config_class: type[GenericConfig] = config_class if config_class is not None else generic_args[0]
+        self.filename: str = filename
+        self.yaml_base_key: str | None = yaml_base_key
+
+    def build(self) -> GenericConfig:
+        """Build the configuration.
+
+        Returns:
+            GenericConfig: The configuration.
+
+        Raises:
+            ApplicationConfigFactoryException: Any error occurred
+        """
+        try:
+            config: GenericConfig = build_config_from_file_in_package(
+                package_name=self.package_name,
+                config_class=self.config_class,
+                filename=self.filename,
+                yaml_base_key=self.yaml_base_key,
+            )
+        except UnableToReadConfigFileError as exception:
+            raise ConfigBuilderError(
+                message="Unable to read the application configuration file.",
+                config_class=self.config_class,
+                package=self.package_name,
+                filename=self.filename,
+            ) from exception
+        except ValueErrorConfigError as exception:
+            raise ConfigBuilderError(
+                message="Value error when creating the configuration object.",
+                config_class=self.config_class,
+                package=self.package_name,
+                filename=self.filename,
+            ) from exception
+        except Exception as exception:
+            raise ConfigBuilderError(
+                message="An error occurred while building the application configuration.",
+                config_class=self.config_class,
+                package=self.package_name,
+                filename=self.filename,
+            ) from exception
+
+        return config

fastapi_factory_utilities/core/app/exceptions.py

@@ -0,0 +1,20 @@
+"""Provides the exceptions for the application factory."""
+
+from ..exceptions import FastAPIFactoryUtilitiesError
+
+
+class BaseApplicationException(BaseException):
+    """Base application exception."""
+
+    pass
+
+
+class ConfigBuilderError(FastAPIFactoryUtilitiesError):
+    """Application configuration factory exception."""
+
+    def __init__(self, message: str, config_class: type, package: str, filename: str) -> None:
+        """Instantiate the exception."""
+        super().__init__(
+            message=f"Unable to build the configuration for the package {package} and "
+            + f"the file {filename} with the class {config_class} - {message}"
+        )