cpl/src/cpl-application/cpl/application/abc/application_abc.py

from abc import ABC, abstractmethod
from typing import Callable, Self

from cpl.application.host import Host
from cpl.core.errors import module_dependency_error
from cpl.core.log.log_level import LogLevel
from cpl.core.log.log_settings import LogSettings
from cpl.core.log.logger_abc import LoggerABC
from cpl.dependency.service_provider import ServiceProvider
from cpl.dependency.typing import TModule


def __not_implemented__(package: str, func: Callable):
    raise NotImplementedError(f"Package {package} is required to use {func.__name__} method")


class ApplicationABC(ABC):
    r"""ABC for the Application class

    Parameters:
        services: :class:`cpl.dependency.service_provider.ServiceProvider`
            Contains instances of prepared objects
    """

    @classmethod
    def extend(cls, name: str | Callable, func: Callable[[Self], Self]):
        r"""Extend the Application with a custom method

        Parameters:
            name: :class:`str`
                Name of the method
            func: :class:`Callable[[Self], Self]`
                Function that takes the Application as a parameter and returns it
        """
        if callable(name):
            name = name.__name__

        setattr(cls, name, func)
        return cls

    @abstractmethod
    def __init__(
        self, services: ServiceProvider, loaded_modules: set[TModule], required_modules: list[str | object] = None
    ):
        self._services = services
        self._modules = loaded_modules
        self._required_modules = (
            [x.__name__ if not isinstance(x, str) else x for x in required_modules] if required_modules else []
        )

    def validate_app_required_modules(self):
        modules_names = {x.__name__ for x in self._modules}
        for module in self._required_modules:
            if module in modules_names:
                continue

            module_dependency_error(
                type(self).__name__,
                module.__name__,
                ImportError(
                    f"Required module '{module}' for application '{self.__class__.__name__}' is not loaded. Load using 'add_module({module})' method."
                ),
            )

    def with_logging(self, level: LogLevel = None):
        if level is None:
            from cpl.core.configuration.configuration import Configuration

            settings = Configuration.get(LogSettings)
            level = settings.level if settings else LogLevel.info

        logger = self._services.get_service(LoggerABC)
        logger.set_level(level)

    def with_permissions(self, *args):
        try:
            from cpl.auth import AuthModule

            AuthModule.with_permissions(*args)
        except ImportError:
            __not_implemented__("cpl-auth", self.with_permissions)

    def with_migrations(self, *args):
        try:
            from cpl.database.database_module import DatabaseModule

            DatabaseModule.with_migrations(self._services, *args)
        except ImportError:
            __not_implemented__("cpl-database", self.with_migrations)

    def with_extension(self, func: Callable[[Self, ...], None], *args, **kwargs):
        r"""Extend the Application with a custom method

        Parameters:
            func: :class:`Callable[[Self], Self]`
                Function that takes the Application as a parameter and returns it
        """
        assert func is not None, "func must not be None"
        assert callable(func), "func must be callable"

        func(self, *args, **kwargs)

    def run(self):
        r"""Entry point

        Called by custom Application.main
        """
        try:
            for module in self._modules:
                if not hasattr(module, "configure") and not callable(getattr(module, "configure")):
                    continue
                module.configure(self._services)

            Host.run_app(self.main)
        except KeyboardInterrupt:
            pass
        finally:
            logger = self._services.get_service(LoggerABC)
            logger.info("Application shutdown")

    @abstractmethod
    def main(self): ...