Renamed project dirs

src/application/cpl/application/__init__.py

@@ -0,0 +1,4 @@
+from .application_builder import ApplicationBuilder
+from .host import Host
+
+__version__ = "1.0.0"

src/application/cpl/application/abc/__init__.py

@@ -0,0 +1,4 @@
+from .application_abc import ApplicationABC
+from .application_extension_abc import ApplicationExtensionABC
+from .startup_abc import StartupABC
+from .startup_extension_abc import StartupExtensionABC

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

@@ -0,0 +1,122 @@
+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__ if not isinstance(module, str) else module,
+                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): ...

src/application/cpl/application/abc/application_extension_abc.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+
+from cpl.dependency.service_provider import ServiceProvider
+
+
+class ApplicationExtensionABC(ABC):
+
+    @staticmethod
+    @abstractmethod
+    def run(services: ServiceProvider): ...

src/application/cpl/application/abc/startup_abc.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+
+from cpl.dependency.service_collection import ServiceCollection
+
+
+class StartupABC(ABC):
+    r"""ABC for the startup class"""
+
+    @staticmethod
+    @abstractmethod
+    def configure_configuration():
+        r"""Creates configuration of application"""
+
+    @staticmethod
+    @abstractmethod
+    def configure_services(service: ServiceCollection):
+        r"""Creates service provider
+
+        Parameter:
+            services: :class:`cpl.dependency.service_collection`
+        """

src/application/cpl/application/abc/startup_extension_abc.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+
+from cpl.dependency import ServiceCollection
+
+
+class StartupExtensionABC(ABC):
+    r"""ABC for startup extension classes"""
+
+    @staticmethod
+    @abstractmethod
+    def configure_configuration():
+        r"""Creates configuration of application"""
+
+    @staticmethod
+    @abstractmethod
+    def configure_services(services: ServiceCollection):
+        r"""Creates service provider
+        Parameter:
+            services: :class:`cpl.dependency.service_collection`
+        """

src/application/cpl/application/application_builder.py

@@ -0,0 +1,75 @@
+import asyncio
+from typing import Type, Optional, TypeVar, Generic
+
+from cpl.application.abc.application_abc import ApplicationABC
+from cpl.application.abc.application_extension_abc import ApplicationExtensionABC
+from cpl.application.abc.startup_abc import StartupABC
+from cpl.application.abc.startup_extension_abc import StartupExtensionABC
+from cpl.application.host import Host
+from cpl.dependency.context import get_provider, use_root_provider
+from cpl.dependency.service_collection import ServiceCollection
+
+TApp = TypeVar("TApp", bound=ApplicationABC)
+
+
+class ApplicationBuilder(Generic[TApp]):
+
+    def __init__(self, app: Type[ApplicationABC]):
+        assert app is not None, "app must not be None"
+        assert issubclass(app, ApplicationABC), "app must be an subclass of ApplicationABC or its subclass"
+
+        self._app = app if app is not None else ApplicationABC
+
+        self._services = ServiceCollection()
+        use_root_provider(self._services.build())
+
+        self._startup: Optional[StartupABC] = None
+        self._app_extensions: list[Type[ApplicationExtensionABC]] = []
+        self._startup_extensions: list[Type[StartupExtensionABC]] = []
+
+        self._async_loop = asyncio.get_event_loop()
+
+    @property
+    def services(self) -> ServiceCollection:
+        return self._services
+
+    @property
+    def service_provider(self):
+        provider = get_provider()
+        if provider is None:
+            provider = self._services.build()
+            use_root_provider(provider)
+
+        return provider
+
+    def with_startup(self, startup: Type[StartupABC]) -> "ApplicationBuilder":
+        self._startup = startup
+        return self
+
+    def with_extension(
+        self,
+        extension: Type[ApplicationExtensionABC | StartupExtensionABC],
+    ) -> "ApplicationBuilder":
+        if (issubclass(extension, ApplicationExtensionABC)) and extension not in self._app_extensions:
+            self._app_extensions.append(extension)
+        elif (issubclass(extension, StartupExtensionABC)) and extension not in self._startup_extensions:
+            self._startup_extensions.append(extension)
+
+        return self
+
+    def build(self) -> TApp:
+        for extension in self._startup_extensions:
+            Host.run(extension.configure_configuration)
+            Host.run(extension.configure_services, self._services)
+
+        if self._startup is not None:
+            Host.run(self._startup.configure_configuration)
+            Host.run(self._startup.configure_services, self._services)
+
+        for extension in self._app_extensions:
+            Host.run(extension.run, self.service_provider)
+
+        use_root_provider(self._services.build())
+        app = self._app(self.service_provider, self._services.loaded_modules)
+        app.validate_app_required_modules()
+        return app

src/application/cpl/application/host.py

@@ -0,0 +1,75 @@
+import asyncio
+from typing import Callable
+
+from cpl.dependency import get_provider
+from cpl.dependency.hosted.startup_task import StartupTask
+
+
+class Host:
+    _loop: asyncio.AbstractEventLoop | None = None
+    _tasks: dict = {}
+
+    @classmethod
+    def get_loop(cls) -> asyncio.AbstractEventLoop:
+        if cls._loop is None:
+            cls._loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(cls._loop)
+        return cls._loop
+
+    @classmethod
+    def run_start_tasks(cls):
+        provider = get_provider()
+        tasks = provider.get_services(StartupTask)
+        loop = cls.get_loop()
+
+        for task in tasks:
+            if asyncio.iscoroutinefunction(task.run):
+                loop.run_until_complete(task.run())
+            else:
+                task.run()
+
+    @classmethod
+    def run_hosted_services(cls):
+        provider = get_provider()
+        services = provider.get_hosted_services()
+        loop = cls.get_loop()
+
+        for service in services:
+            if asyncio.iscoroutinefunction(service.start):
+                cls._tasks[service] = loop.create_task(service.start())
+
+    @classmethod
+    async def _stop_all(cls):
+        for service in cls._tasks.keys():
+            if asyncio.iscoroutinefunction(service.stop):
+                await service.stop()
+
+        for task in cls._tasks.values():
+            task.cancel()
+
+        cls._tasks.clear()
+
+    @classmethod
+    def run_app(cls, func: Callable, *args, **kwargs):
+        cls.run_start_tasks()
+        cls.run_hosted_services()
+
+        async def runner():
+            try:
+                if asyncio.iscoroutinefunction(func):
+                    await func(*args, **kwargs)
+                else:
+                    func(*args, **kwargs)
+            except (KeyboardInterrupt, asyncio.CancelledError):
+                pass
+            finally:
+                await cls._stop_all()
+
+        cls.get_loop().run_until_complete(runner())
+
+    @classmethod
+    def run(cls, func: Callable, *args, **kwargs):
+        if asyncio.iscoroutinefunction(func):
+            return cls.get_loop().run_until_complete(func(*args, **kwargs))
+
+        return func(*args, **kwargs)

src/application/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=70.1.0", "wheel>=0.43.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cpl-application"
+version = "2024.7.0"
+description = "CPL application"
+readme ="CPL application package"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+authors = [
+    { name = "Sven Heidemann", email = "sven.heidemann@sh-edraft.de" }
+]
+keywords = ["cpl", "application", "backend", "shared", "library"]
+
+dynamic = ["dependencies", "optional-dependencies"]
+
+[project.urls]
+Homepage = "https://www.sh-edraft.de"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["cpl*"]
+
+[tool.setuptools.dynamic]
+dependencies = { file = ["requirements.txt"] }
+optional-dependencies.dev = { file = ["requirements.dev.txt"] }
+
+

src/application/requirements.dev.txt

@@ -0,0 +1 @@
+black==25.1.0

src/application/requirements.txt

@@ -0,0 +1,2 @@
+cpl-core
+cpl-dependency