Improved structure and added basics for database module

src/sh_edraft/service/providing/__init__.py

@@ -0,0 +1,3 @@
+# imports:
+
+from .service_provider import ServiceProviderBase

src/sh_edraft/service/providing/base/__init__.py

@@ -0,0 +1,3 @@
+# imports:
+
+from .service_provider_base import ServiceProviderBase

src/sh_edraft/service/providing/base/service_provider_base.py

@@ -0,0 +1,27 @@
+from abc import abstractmethod
+from collections import Callable
+from typing import Type
+
+from sh_edraft.service.base.service_base import ServiceBase
+
+
+class ServiceProviderBase(ServiceBase):
+
+    @abstractmethod
+    def __init__(self):
+        ServiceBase.__init__(self)
+
+    @abstractmethod
+    def add_transient(self, service_type: Type[ServiceBase], service: Type[ServiceBase]): pass
+
+    @abstractmethod
+    def add_scoped(self, service_type: Type[ServiceBase], service: Type[ServiceBase]): pass
+
+    @abstractmethod
+    def add_singleton(self, service_type: Type[ServiceBase], service: Callable[ServiceBase]): pass
+
+    @abstractmethod
+    def get_service(self, instance_type: Type[ServiceBase]) -> Callable[ServiceBase]: pass
+
+    @abstractmethod
+    def remove_service(self, instance_type: type): pass

src/sh_edraft/service/providing/model/__init__.py

@@ -0,0 +1,3 @@
+# imports:
+
+from .provide_state import ProvideState

src/sh_edraft/service/providing/model/provide_state.py

@@ -0,0 +1,18 @@
+from typing import Type
+
+from sh_edraft.service.base.service_base import ServiceBase
+
+
+class ProvideState:
+
+    def __init__(self, service: Type[ServiceBase] = None, args: tuple = None):
+        self._service: Type[ServiceBase] = service
+        self._args: tuple = args
+
+    @property
+    def service(self):
+        return self._service
+
+    @property
+    def args(self) -> tuple:
+        return self._args

src/sh_edraft/service/providing/service_provider.py

@@ -0,0 +1,80 @@
+from collections import Callable
+from inspect import signature, Parameter
+from typing import Type
+
+from sh_edraft.configuration.base.configuration_model_base import ConfigurationModelBase
+from sh_edraft.hosting.base.application_runtime_base import ApplicationRuntimeBase
+from sh_edraft.service.providing.base.service_provider_base import ServiceProviderBase
+from sh_edraft.service.base.service_base import ServiceBase
+
+
+class ServiceProvider(ServiceProviderBase):
+
+    def __init__(self, app_runtime: ApplicationRuntimeBase):
+        ServiceProviderBase.__init__(self)
+        self._app_runtime: ApplicationRuntimeBase = app_runtime
+
+        self._transient_services: dict[Type[ServiceBase], Type[ServiceBase]] = {}
+        self._scoped_services: dict[Type[ServiceBase], Type[ServiceBase]] = {}
+        self._singleton_services: dict[Type[ServiceBase], ServiceBase] = {}
+
+    def create(self): pass
+
+    def _create_instance(self, service: Callable[ServiceBase]) -> ServiceBase:
+        sig = signature(service.__init__)
+        params = []
+        for param in sig.parameters.items():
+            parameter = param[1]
+            if parameter.name != 'self' and parameter.annotation != Parameter.empty:
+                if issubclass(parameter.annotation, ApplicationRuntimeBase):
+                    params.append(self._app_runtime)
+
+                elif issubclass(parameter.annotation, ServiceBase):
+                    params.append(self.get_service(parameter.annotation))
+
+                elif issubclass(parameter.annotation, ConfigurationModelBase):
+                    params.append(self._app_runtime.configuration.get_configuration(parameter.annotation))
+
+        return service(*params)
+
+    def add_transient(self, service_type: Type[ServiceBase], service: Type[ServiceBase]):
+        self._transient_services[service_type] = service
+
+    def add_scoped(self, service_type: Type[ServiceBase], service: Type[ServiceBase]):
+        self._scoped_services[service_type] = service
+
+    def add_singleton(self, service_type: Type[ServiceBase], service: Callable[ServiceBase]):
+        for known_service in self._singleton_services:
+            if type(known_service) == service_type:
+                raise Exception(f'Service with type {service_type} already exists')
+
+        self._singleton_services[service_type] = self._create_instance(service)
+
+    def get_service(self, instance_type: Type[ServiceBase]) -> Callable[ServiceBase]:
+        for service in self._transient_services:
+            if service == instance_type and isinstance(self._transient_services[service], type(instance_type)):
+                return self._create_instance(self._transient_services[service])
+
+        for service in self._scoped_services:
+            if service == instance_type and isinstance(self._scoped_services[service], type(instance_type)):
+                return self._create_instance(self._scoped_services[service])
+
+        for service in self._singleton_services:
+            if service == instance_type and isinstance(self._singleton_services[service], instance_type):
+                return self._singleton_services[service]
+
+    def remove_service(self, instance_type: Type[ServiceBase]):
+        for service in self._transient_services:
+            if isinstance(service, type(instance_type)):
+                del self._transient_services[service]
+                return
+
+        for service in self._scoped_services:
+            if isinstance(service, type(instance_type)):
+                del self._scoped_services[service]
+                return
+
+        for service in self._singleton_services:
+            if isinstance(service, instance_type):
+                del self._singleton_services[service]
+                return