Restructuring

src/cpl-dependency/cpl/dependency/__init__.py

@@ -0,0 +1,8 @@
+from .scope import Scope
+from .scope_abc import ScopeABC
+from .service_collection import ServiceCollection
+from .service_collection_abc import ServiceCollectionABC
+from .service_descriptor import ServiceDescriptor
+from .service_lifetime_enum import ServiceLifetimeEnum
+from .service_provider import ServiceProvider
+from .service_provider_abc import ServiceProviderABC

src/cpl-dependency/cpl/dependency/scope.py

@@ -0,0 +1,22 @@
+from cpl.dependency.scope_abc import ScopeABC
+from cpl.dependency.service_provider_abc import ServiceProviderABC
+
+
+class Scope(ScopeABC):
+    def __init__(self, service_provider: ServiceProviderABC):
+        self._service_provider = service_provider
+        self._service_provider.set_scope(self)
+        ScopeABC.__init__(self)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.dispose()
+
+    @property
+    def service_provider(self) -> ServiceProviderABC:
+        return self._service_provider
+
+    def dispose(self):
+        self._service_provider = None

src/cpl-dependency/cpl/dependency/scope_abc.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+
+
+class ScopeABC(ABC):
+    r"""ABC for the class :class:`cpl.dependency.scope.Scope`"""
+
+    def __init__(self):
+        pass
+
+    @property
+    @abstractmethod
+    def service_provider(self):
+        r"""Returns to service provider of scope
+
+        Returns:
+            Object of type :class:`cpl.dependency.service_provider_abc.ServiceProviderABC`
+        """
+
+    @abstractmethod
+    def dispose(self):
+        r"""Sets service_provider to None"""

src/cpl-dependency/cpl/dependency/scope_builder.py

@@ -0,0 +1,18 @@
+from cpl.dependency.scope import Scope
+from cpl.dependency.scope_abc import ScopeABC
+from cpl.dependency.service_provider_abc import ServiceProviderABC
+
+
+class ScopeBuilder:
+    r"""Class to build :class:`cpl.dependency.scope.Scope`"""
+
+    def __init__(self, service_provider: ServiceProviderABC) -> None:
+        self._service_provider = service_provider
+
+    def build(self) -> ScopeABC:
+        r"""Returns scope
+
+        Returns:
+            Object of type :class:`cpl.dependency.scope.Scope`
+        """
+        return Scope(self._service_provider)

src/cpl-dependency/cpl/dependency/service_collection.py

@@ -0,0 +1,76 @@
+from typing import Union, Type, Callable, Optional
+
+from cpl.database.context.database_context_abc import DatabaseContextABC
+from cpl.database.database_settings import DatabaseSettings
+from cpl.dependency.service_collection_abc import ServiceCollectionABC
+from cpl.dependency.service_descriptor import ServiceDescriptor
+from cpl.dependency.service_lifetime_enum import ServiceLifetimeEnum
+from cpl.dependency.service_provider import ServiceProvider
+from cpl.dependency.service_provider_abc import ServiceProviderABC
+from cpl.core.log.logger import Logger
+from cpl.core.log.logger_abc import LoggerABC
+from cpl.core.pipes.pipe_abc import PipeABC
+from cpl.core.typing import T, Service
+
+
+class ServiceCollection(ServiceCollectionABC):
+    r"""Representation of the collection of services"""
+
+    def __init__(self):
+        ServiceCollectionABC.__init__(self)
+        self._database_context: Optional[DatabaseContextABC] = None
+        self._service_descriptors: list[ServiceDescriptor] = []
+
+    def _add_descriptor(self, service: Union[type, object], lifetime: ServiceLifetimeEnum, base_type: Callable = None):
+        found = False
+        for descriptor in self._service_descriptors:
+            if isinstance(service, descriptor.service_type):
+                found = True
+
+        if found:
+            service_type = service
+            if not isinstance(service, type):
+                service_type = type(service)
+
+            raise Exception(f"Service of type {service_type} already exists")
+
+        self._service_descriptors.append(ServiceDescriptor(service, lifetime, base_type))
+
+    def _add_descriptor_by_lifetime(self, service_type: Type, lifetime: ServiceLifetimeEnum, service: Callable = None):
+        if service is not None:
+            self._add_descriptor(service, lifetime, service_type)
+        else:
+            self._add_descriptor(service_type, lifetime)
+
+        return self
+
+    def add_db_context(self, db_context_type: Type[DatabaseContextABC], db_settings: DatabaseSettings):
+        self.add_singleton(DatabaseContextABC, db_context_type)
+        self._database_context = self.build_service_provider().get_service(DatabaseContextABC)
+        self._database_context.connect(db_settings)
+
+    def add_logging(self):
+        self.add_transient(LoggerABC, Logger)
+        return self
+
+    def add_pipes(self):
+        for pipe in PipeABC.__subclasses__():
+            self.add_transient(PipeABC, pipe)
+        return self
+
+    def add_singleton(self, service_type: T, service: Service = None):
+        self._add_descriptor_by_lifetime(service_type, ServiceLifetimeEnum.singleton, service)
+        return self
+
+    def add_scoped(self, service_type: T, service: Service = None):
+        self._add_descriptor_by_lifetime(service_type, ServiceLifetimeEnum.scoped, service)
+        return self
+
+    def add_transient(self, service_type: T, service: Service = None):
+        self._add_descriptor_by_lifetime(service_type, ServiceLifetimeEnum.transient, service)
+        return self
+
+    def build_service_provider(self) -> ServiceProviderABC:
+        sp = ServiceProvider(self._service_descriptors, self._database_context)
+        ServiceProviderABC.set_global_provider(sp)
+        return sp

src/cpl-dependency/cpl/dependency/service_collection_abc.py

@@ -0,0 +1,90 @@
+from abc import abstractmethod, ABC
+from typing import Type
+
+from cpl.database.context.database_context_abc import DatabaseContextABC
+from cpl.database.database_settings import DatabaseSettings
+from cpl.dependency.service_provider_abc import ServiceProviderABC
+from cpl.core.typing import T, Source
+
+
+class ServiceCollectionABC(ABC):
+    r"""ABC for the class :class:`cpl.dependency.service_collection.ServiceCollection`"""
+
+    @abstractmethod
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def add_db_context(self, db_context_type: Type[DatabaseContextABC], db_settings: DatabaseSettings):
+        r"""Adds database context
+
+        Parameter:
+            db_context: Type[:class:`cpl.database.context.database_context_abc.DatabaseContextABC`]
+                Database context
+        """
+
+    @abstractmethod
+    def add_logging(self):
+        r"""Adds the CPL internal logger"""
+
+    @abstractmethod
+    def add_pipes(self):
+        r"""Adds the CPL internal pipes as transient"""
+
+    def add_translation(self):
+        r"""Adds the CPL translation"""
+        raise NotImplementedError("You should install and use the cpl-translation package")
+
+    def add_mail(self):
+        r"""Adds the CPL mail"""
+        raise NotImplementedError("You should install and use the cpl-mail package")
+
+    @abstractmethod
+    def add_transient(self, service_type: T, service: T = None) -> "ServiceCollectionABC":
+        r"""Adds a service with transient lifetime
+
+        Parameter:
+            service_type: :class:`Type`
+                Type of the service
+            service: :class:`Callable`
+                Object of the service
+
+        Returns:
+            self: :class:`cpl.dependency.service_collection_abc.ServiceCollectionABC`
+        """
+
+    @abstractmethod
+    def add_scoped(self, service_type: T, service: T = None) -> "ServiceCollectionABC":
+        r"""Adds a service with scoped lifetime
+
+        Parameter:
+            service_type: :class:`Type`
+                Type of the service
+            service: :class:`Callable`
+                Object of the service
+
+        Returns:
+            self: :class:`cpl.dependency.service_collection_abc.ServiceCollectionABC`
+        """
+
+    @abstractmethod
+    def add_singleton(self, service_type: T, service: T = None) -> "ServiceCollectionABC":
+        r"""Adds a service with singleton lifetime
+
+        Parameter:
+            service_type: :class:`Type`
+                Type of the service
+            service: :class:`Callable`
+                Object of the service
+
+        Returns:
+            self: :class:`cpl.dependency.service_collection_abc.ServiceCollectionABC`
+        """
+
+    @abstractmethod
+    def build_service_provider(self) -> ServiceProviderABC:
+        r"""Creates instance of the service provider
+
+        Returns:
+            Object of type :class:`cpl.dependency.service_provider_abc.ServiceProviderABC`
+        """

src/cpl-dependency/cpl/dependency/service_descriptor.py

@@ -0,0 +1,46 @@
+from typing import Union, Optional
+
+from cpl.dependency.service_lifetime_enum import ServiceLifetimeEnum
+
+
+class ServiceDescriptor:
+    r"""Descriptor of a service
+
+    Parameter:
+        implementation: Union[:class:`type`, Optional[:class:`object`]]
+            Object or type of service
+        lifetime: :class:`cpl.dependency.service_lifetime_enum.ServiceLifetimeEnum`
+            Lifetime of the service
+    """
+
+    def __init__(self, implementation: Union[type, Optional[object]], lifetime: ServiceLifetimeEnum, base_type=None):
+        self._service_type = implementation
+        self._implementation = implementation
+        self._lifetime = lifetime
+
+        if not isinstance(implementation, type):
+            self._service_type = type(implementation)
+        else:
+            self._implementation = None
+
+        self._base_type = base_type if base_type is not None else self._service_type
+
+    @property
+    def service_type(self) -> type:
+        return self._service_type
+
+    @property
+    def base_type(self) -> type:
+        return self._base_type
+
+    @property
+    def implementation(self) -> Union[type, Optional[object]]:
+        return self._implementation
+
+    @implementation.setter
+    def implementation(self, implementation: Union[type, Optional[object]]):
+        self._implementation = implementation
+
+    @property
+    def lifetime(self) -> ServiceLifetimeEnum:
+        return self._lifetime

src/cpl-dependency/cpl/dependency/service_lifetime_enum.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class ServiceLifetimeEnum(Enum):
+    singleton = 0
+    scoped = 1
+    transient = 2

src/cpl-dependency/cpl/dependency/service_provider.py

@@ -0,0 +1,172 @@
+import copy
+import typing
+from inspect import signature, Parameter, Signature
+from typing import Optional
+
+from cpl.core.configuration import Configuration
+from cpl.core.configuration.configuration_model_abc import ConfigurationModelABC
+from cpl.database.context.database_context_abc import DatabaseContextABC
+from cpl.core.environment import Environment
+from cpl.core.typing import T, R, Source
+from cpl.dependency.scope_abc import ScopeABC
+from cpl.dependency.scope_builder import ScopeBuilder
+from cpl.dependency.service_descriptor import ServiceDescriptor
+from cpl.dependency.service_lifetime_enum import ServiceLifetimeEnum
+from cpl.dependency.service_provider_abc import ServiceProviderABC
+
+
+class ServiceProvider(ServiceProviderABC):
+    r"""Provider for the services
+
+    Parameter
+    ---------
+        service_descriptors: list[:class:`cpl.dependency.service_descriptor.ServiceDescriptor`]
+            Descriptor of the service
+        config: :class:`cpl.core.configuration.configuration_abc.ConfigurationABC`
+            CPL Configuration
+        db_context: Optional[:class:`cpl.database.context.database_context_abc.DatabaseContextABC`]
+            Database representation
+    """
+
+    def __init__(
+        self,
+        service_descriptors: list[ServiceDescriptor],
+        db_context: Optional[DatabaseContextABC],
+    ):
+        ServiceProviderABC.__init__(self)
+
+        self._service_descriptors: list[ServiceDescriptor] = service_descriptors
+        self._database_context = db_context
+        self._scope: Optional[ScopeABC] = None
+
+    def _find_service(self, service_type: type) -> Optional[ServiceDescriptor]:
+        for descriptor in self._service_descriptors:
+            if descriptor.service_type == service_type or issubclass(descriptor.base_type, service_type):
+                return descriptor
+
+        return None
+
+    def _get_service(self, parameter: Parameter, origin_service_type: type = None) -> Optional[object]:
+        for descriptor in self._service_descriptors:
+            if descriptor.service_type == parameter.annotation or issubclass(
+                descriptor.service_type, parameter.annotation
+            ):
+                if descriptor.implementation is not None:
+                    return descriptor.implementation
+
+                implementation = self._build_service(descriptor.service_type, origin_service_type=origin_service_type)
+                if descriptor.lifetime == ServiceLifetimeEnum.singleton:
+                    descriptor.implementation = implementation
+
+                return implementation
+
+        # raise Exception(f'Service {parameter.annotation} not found')
+
+    def _get_services(self, t: type, *args, service_type: type = None, **kwargs) -> list[Optional[object]]:
+        implementations = []
+        for descriptor in self._service_descriptors:
+            if descriptor.service_type == t or issubclass(descriptor.service_type, t):
+                if descriptor.implementation is not None:
+                    implementations.append(descriptor.implementation)
+                    continue
+
+                implementation = self._build_service(descriptor.service_type, *args, service_type, **kwargs)
+                if descriptor.lifetime == ServiceLifetimeEnum.singleton:
+                    descriptor.implementation = implementation
+
+                implementations.append(implementation)
+
+        return implementations
+
+    def _build_by_signature(self, sig: Signature, origin_service_type: type) -> list[R]:
+        params = []
+        for param in sig.parameters.items():
+            parameter = param[1]
+            if parameter.name != "self" and parameter.annotation != Parameter.empty:
+                if typing.get_origin(parameter.annotation) == list:
+                    params.append(self._get_services(typing.get_args(parameter.annotation)[0], origin_service_type))
+
+                elif parameter.annotation == Source:
+                    params.append(origin_service_type.__name__)
+
+                elif issubclass(parameter.annotation, ServiceProviderABC):
+                    params.append(self)
+
+                elif issubclass(parameter.annotation, Environment):
+                    params.append(Environment)
+
+                elif issubclass(parameter.annotation, DatabaseContextABC):
+                    params.append(self._database_context)
+
+                elif issubclass(parameter.annotation, ConfigurationModelABC):
+                    params.append(Configuration.get(parameter.annotation))
+
+                elif issubclass(parameter.annotation, Configuration):
+                    params.append(Configuration)
+
+                else:
+                    params.append(self._get_service(parameter, origin_service_type))
+
+        return params
+
+    def _build_service(self, service_type: type, *args, origin_service_type: type = None, **kwargs) -> object:
+        if origin_service_type is None:
+            origin_service_type = service_type
+
+        for descriptor in self._service_descriptors:
+            if descriptor.service_type == service_type or issubclass(descriptor.service_type, service_type):
+                if descriptor.implementation is not None:
+                    service_type = type(descriptor.implementation)
+                else:
+                    service_type = descriptor.service_type
+
+                break
+
+        sig = signature(service_type.__init__)
+        params = self._build_by_signature(sig, origin_service_type)
+
+        return service_type(*params, *args, **kwargs)
+
+    def set_scope(self, scope: ScopeABC):
+        self._scope = scope
+
+    def create_scope(self) -> ScopeABC:
+        descriptors = []
+
+        for descriptor in self._service_descriptors:
+            if descriptor.lifetime == ServiceLifetimeEnum.singleton:
+                descriptors.append(descriptor)
+            else:
+                descriptors.append(copy.deepcopy(descriptor))
+
+        sb = ScopeBuilder(ServiceProvider(descriptors, self._database_context))
+        return sb.build()
+
+    def get_service(self, service_type: T, *args, **kwargs) -> Optional[R]:
+        result = self._find_service(service_type)
+
+        if result is None:
+            return None
+
+        if result.implementation is not None:
+            return result.implementation
+
+        implementation = self._build_service(service_type, *args, **kwargs)
+        if (
+            result.lifetime == ServiceLifetimeEnum.singleton
+            or result.lifetime == ServiceLifetimeEnum.scoped
+            and self._scope is not None
+        ):
+            result.implementation = implementation
+
+        return implementation
+
+    def get_services(self, service_type: T, *args, **kwargs) -> list[Optional[R]]:
+        implementations = []
+
+        if typing.get_origin(service_type) == list:
+            raise Exception(f"Invalid type {service_type}! Expected single type not list of type")
+
+        implementations.extend(self._get_services(service_type))
+
+        return implementations

src/cpl-dependency/cpl/dependency/service_provider_abc.py

@@ -0,0 +1,111 @@
+import functools
+from abc import abstractmethod, ABC
+from inspect import Signature, signature
+from typing import Optional
+
+from cpl.dependency.scope_abc import ScopeABC
+from cpl.core.typing import T, R
+
+
+class ServiceProviderABC(ABC):
+    r"""ABC for the class :class:`cpl.dependency.service_provider.ServiceProvider`"""
+
+    _provider: Optional["ServiceProviderABC"] = None
+
+    @abstractmethod
+    def __init__(self):
+        pass
+
+    @classmethod
+    def set_global_provider(cls, provider: "ServiceProviderABC"):
+        cls._provider = provider
+
+    @abstractmethod
+    def _build_by_signature(self, sig: Signature, origin_service_type: type) -> list[R]:
+        pass
+
+    @abstractmethod
+    def _build_service(self, service_type: type, *args, **kwargs) -> object:
+        r"""Creates instance of given type
+
+        Parameter
+        ---------
+            instance_type: :class:`type`
+                The type of the searched instance
+
+        Returns
+        -------
+            Object of the given type
+        """
+
+    @abstractmethod
+    def set_scope(self, scope: ScopeABC):
+        r"""Sets the scope of service provider
+
+        Parameter
+        ---------
+            Object of type :class:`cpl.dependency.scope_abc.ScopeABC`
+                Service scope
+        """
+
+    @abstractmethod
+    def create_scope(self) -> ScopeABC:
+        r"""Creates a service scope
+
+        Returns
+        -------
+            Object of type :class:`cpl.dependency.scope_abc.ScopeABC`
+        """
+
+    @abstractmethod
+    def get_service(self, instance_type: T, *args, **kwargs) -> Optional[R]:
+        r"""Returns instance of given type
+
+        Parameter
+        ---------
+            instance_type: :class:`cpl.core.type.T`
+                The type of the searched instance
+
+        Returns
+        -------
+            Object of type Optional[:class:`cpl.core.type.T`]
+        """
+
+    @abstractmethod
+    def get_services(self, service_type: T, *args, **kwargs) -> list[Optional[R]]:
+        r"""Returns instance of given type
+
+        Parameter
+        ---------
+            service_type: :class:`cpl.core.type.T`
+                The type of the searched instance
+
+        Returns
+        -------
+            Object of type list[Optional[:class:`cpl.core.type.T`]
+        """
+
+    @classmethod
+    def inject(cls, f=None):
+        r"""Decorator to allow injection into static and class methods
+
+        Parameter
+        ---------
+            f: Callable
+
+        Returns
+        -------
+            function
+        """
+        if f is None:
+            return functools.partial(cls.inject)
+
+        @functools.wraps(f)
+        def inner(*args, **kwargs):
+            if cls._provider is None:
+                raise Exception(f"{cls.__name__} not build!")
+
+            injection = [x for x in cls._provider._build_by_signature(signature(f)) if x is not None]
+            return f(*args, *injection, **kwargs)
+
+        return inner

src/cpl-dependency/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-dependency"
+version = "2024.7.0"
+description = "CPL dependency"
+readme ="CPL dependency package"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+authors = [
+    { name = "Sven Heidemann", email = "sven.heidemann@sh-edraft.de" }
+]
+keywords = ["cpl", "dependency", "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/cpl-dependency/requirements.dev.txt

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

src/cpl-dependency/requirements.txt

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