Cleanup for mysql

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

@@ -1,7 +1,6 @@
 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

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

@@ -1,24 +1,26 @@
 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
+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
 
 
-class ServiceCollection(ServiceCollectionABC):
+class ServiceCollection:
     r"""Representation of the collection of services"""
 
+    _modules: dict[str, Callable] = {}
+
+    @classmethod
+    def with_module(cls, func: Callable, name: str = None):
+        cls._modules[func.__name__ if name is None else name] = func
+        return cls
+
     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):
@@ -44,10 +46,19 @@ class ServiceCollection(ServiceCollectionABC):
 
         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_module(self, module: str | object):
+        if not isinstance(module, str):
+            module = module.__name__
+
+        if module not in self._modules:
+            raise ValueError(f"Module {module} not found")
+
+        self._modules[module](self)
+
+    # def add_mysql(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)
@@ -71,6 +82,6 @@ class ServiceCollection(ServiceCollectionABC):
         return self
 
     def build_service_provider(self) -> ServiceProviderABC:
-        sp = ServiceProvider(self._service_descriptors, self._database_context)
+        sp = ServiceProvider(self._service_descriptors)
         ServiceProviderABC.set_global_provider(sp)
         return sp

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

@@ -1,90 +0,0 @@
-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_provider.py

@@ -5,7 +5,6 @@ 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
@@ -31,12 +30,10 @@ class ServiceProvider(ServiceProviderABC):
     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]:
@@ -95,9 +92,6 @@ class ServiceProvider(ServiceProviderABC):
                 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))