Added enumerable order & added array & removed collection

.gitea/workflows/prepare.yaml

@@ -25,11 +25,7 @@ jobs:
           git tag
           DATE=$(date +'%Y.%m.%d')
           TAG_COUNT=$(git tag -l "${DATE}.*" | wc -l)
-          if [ "$TAG_COUNT" -eq 0 ]; then
-            BUILD_NUMBER=0
-          else
-            BUILD_NUMBER=$(($TAG_COUNT + 1))
-          fi
+          BUILD_NUMBER=$(($TAG_COUNT + 1))
           
           VERSION_SUFFIX=${{ inputs.version_suffix }}
           if [ -n "$VERSION_SUFFIX" ] && [ "$VERSION_SUFFIX" = "dev" ]; then

example/api/src/main.py

@@ -1,85 +0,0 @@
-from starlette.responses import JSONResponse
-
-from cpl.api.api_module import ApiModule
-from cpl.api.application.web_app import WebApp
-from cpl.application.application_builder import ApplicationBuilder
-from cpl.auth import AuthModule
-from cpl.auth.permission.permissions import Permissions
-from cpl.auth.schema import AuthUser, Role
-from cpl.core.configuration import Configuration
-from cpl.core.console import Console
-from cpl.core.environment import Environment
-from cpl.core.utils.cache import Cache
-from cpl.database.mysql.mysql_module import MySQLModule
-from scoped_service import ScopedService
-from service import PingService
-
-
-def main():
-    builder = ApplicationBuilder[WebApp](WebApp)
-
-    Configuration.add_json_file(f"appsettings.json")
-    Configuration.add_json_file(f"appsettings.{Environment.get_environment()}.json")
-    Configuration.add_json_file(f"appsettings.{Environment.get_host_name()}.json", optional=True)
-
-    # builder.services.add_logging()
-    builder.services.add_structured_logging()
-    builder.services.add_transient(PingService)
-    builder.services.add_module(MySQLModule)
-    builder.services.add_module(ApiModule)
-
-    builder.services.add_scoped(ScopedService)
-
-    builder.services.add_cache(AuthUser)
-    builder.services.add_cache(Role)
-
-    app = builder.build()
-    app.with_logging()
-
-    app.with_authentication()
-    app.with_authorization()
-
-    app.with_route(
-        path="/route1",
-        fn=lambda r: JSONResponse("route1"),
-        method="GET",
-        authentication=True,
-        permissions=[Permissions.administrator],
-    )
-    app.with_routes_directory("routes")
-
-    provider = builder.service_provider
-    user_cache = provider.get_service(Cache[AuthUser])
-    role_cache = provider.get_service(Cache[Role])
-
-    if role_cache == user_cache:
-        raise Exception("Cache service is not working")
-
-    s1 = provider.get_service(ScopedService)
-    s2 = provider.get_service(ScopedService)
-
-    if s1.name == s2.name:
-        raise Exception("Scoped service is not working")
-
-    with provider.create_scope() as scope:
-        s3 = scope.get_service(ScopedService)
-        s4 = scope.get_service(ScopedService)
-
-        if s3.name != s4.name:
-            raise Exception("Scoped service is not working")
-
-    if s1.name == s3.name:
-        raise Exception("Scoped service is not working")
-
-    Console.write_line(
-        s1.name,
-        s2.name,
-        s3.name,
-        s4.name,
-    )
-
-    app.run()
-
-
-if __name__ == "__main__":
-    main()

example/api/src/scoped_service.py

@@ -1,14 +0,0 @@
-from cpl.core.console.console import Console
-from cpl.core.utils.string import String
-
-
-class ScopedService:
-    def __init__(self):
-        self._name = String.random(8)
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    def run(self):
-        Console.write_line(f"Im {self._name}")

example/custom/api/src/main.py

@@ -0,0 +1,47 @@
+from starlette.responses import JSONResponse
+
+from cpl import api
+from cpl.api.application.web_app import WebApp
+from cpl.application import ApplicationBuilder
+from cpl.auth.permission.permissions import Permissions
+from cpl.auth.schema import AuthUser, Role
+from cpl.core.configuration import Configuration
+from cpl.core.environment import Environment
+from cpl.core.utils.cache import Cache
+from service import PingService
+
+
+def main():
+    builder = ApplicationBuilder[WebApp](WebApp)
+
+    Configuration.add_json_file(f"appsettings.json")
+    Configuration.add_json_file(f"appsettings.{Environment.get_environment()}.json")
+    Configuration.add_json_file(f"appsettings.{Environment.get_host_name()}.json", optional=True)
+
+    # builder.services.add_logging()
+    builder.services.add_structured_logging()
+    builder.services.add_transient(PingService)
+    builder.services.add_module(api)
+
+    builder.services.add_cache(AuthUser)
+    builder.services.add_cache(Role)
+
+    app = builder.build()
+    app.with_logging()
+    app.with_database()
+
+    app.with_authentication()
+    app.with_authorization()
+
+    app.with_route(path="/route1", fn=lambda r: JSONResponse("route1"), method="GET", authentication=True, permissions=[Permissions.administrator])
+    app.with_routes_directory("routes")
+
+    provider = builder.service_provider
+    user_cache = provider.get_service(Cache[AuthUser])
+    role_cache = provider.get_service(Cache[Role])
+
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

example/custom/api/src/routes/ping.py

@@ -5,17 +5,12 @@ from starlette.responses import JSONResponse
 
 from cpl.api import APILogger
 from cpl.api.router import Router
-from cpl.core.console import Console
-from cpl.dependency import ServiceProvider
-from scoped_service import ScopedService
 
 
 @Router.authenticate()
 # @Router.authorize(permissions=[Permissions.administrator])
 # @Router.authorize(policies=["test"])
 @Router.get(f"/ping")
-async def ping(r: Request, ping: PingService, logger: APILogger, provider: ServiceProvider, scoped: ScopedService):
+async def ping(r: Request, ping: PingService, logger: APILogger):
     logger.info(f"Ping: {ping}")
-
-    Console.write_line(scoped.name)
     return JSONResponse(ping.ping(r))

example/custom/database/cpl.json

@@ -0,0 +1,40 @@
+{
+  "Project": {
+    "Name": "database",
+    "Version": {
+      "Major": "0",
+      "Minor": "0",
+      "Micro": "0"
+    },
+    "Author": "",
+    "AuthorEmail": "",
+    "Description": "",
+    "LongDescription": "",
+    "URL": "",
+    "CopyrightDate": "",
+    "CopyrightName": "",
+    "LicenseName": "",
+    "LicenseDescription": "",
+    "Dependencies": [
+      "sh_cpl==2021.4.2.dev1"
+    ],
+    "PythonVersion": ">=3.9.2",
+    "PythonPath": {},
+    "Classifiers": []
+  },
+  "Build": {
+    "ProjectType": "console",
+    "SourcePath": "src",
+    "OutputPath": "dist",
+    "Main": "main",
+    "EntryPoint": "database",
+    "IncludePackageData": false,
+    "Included": [],
+    "Excluded": [
+      "*/__pycache__",
+      "*/logs",
+      "*/tests"
+    ],
+    "PackageData": {}
+  }
+}

example/custom/database/src/application.py

@@ -3,8 +3,7 @@ from cpl.auth.keycloak import KeycloakAdmin
 from cpl.core.console import Console
 from cpl.core.environment import Environment
 from cpl.core.log import LoggerABC
-from cpl.dependency import ServiceProvider
-from cpl.dependency.typing import Modules
+from cpl.dependency import ServiceProviderABC
 from model.city import City
 from model.city_dao import CityDao
 from model.user import User
@@ -12,8 +11,8 @@ from model.user_dao import UserDao
 
 
 class Application(ApplicationABC):
-    def __init__(self, services: ServiceProvider, modules: Modules):
-        ApplicationABC.__init__(self, services, modules)
+    def __init__(self, services: ServiceProviderABC):
+        ApplicationABC.__init__(self, services)
 
         self._logger = services.get_service(LoggerABC)
 

example/custom/database/src/main_simplified.py

@@ -3,7 +3,6 @@ from cpl.application import ApplicationBuilder
 from cpl.auth.permission.permissions_registry import PermissionsRegistry
 from cpl.core.console import Console
 from cpl.core.log import LogLevel
-from cpl.database import DatabaseModule
 from custom_permissions import CustomPermissions
 from startup import Startup
 
@@ -11,12 +10,13 @@ from startup import Startup
 def main():
     builder = ApplicationBuilder(Application).with_startup(Startup)
     builder.services.add_logging()
+
     app = builder.build()
 
     app.with_logging(LogLevel.trace)
     app.with_permissions(CustomPermissions)
     app.with_migrations("./scripts")
-    # app.with_seeders()
+    app.with_seeders()
 
     Console.write_line(CustomPermissions.test.value in PermissionsRegistry.get())
     app.run()

example/custom/database/src/startup.py

@@ -1,14 +1,11 @@
 from cpl import auth
 from cpl.application.abc.startup_abc import StartupABC
 from cpl.auth import permission
-from cpl.auth.auth_module import AuthModule
-from cpl.auth.permission.permission_module import PermissionsModule
 from cpl.core.configuration import Configuration
 from cpl.core.environment import Environment
 from cpl.core.log import Logger, LoggerABC
-from cpl.database import mysql, DatabaseModule
+from cpl.database import mysql
 from cpl.database.abc.data_access_object_abc import DataAccessObjectABC
-from cpl.database.mysql.mysql_module import MySQLModule
 from cpl.dependency import ServiceCollection
 from model.city_dao import CityDao
 from model.user_dao import UserDao
@@ -24,10 +21,9 @@ class Startup(StartupABC):
 
     @staticmethod
     async def configure_services(services: ServiceCollection):
-        services.add_module(MySQLModule)
-        services.add_module(DatabaseModule)
-        services.add_module(AuthModule)
-        services.add_module(PermissionsModule)
+        services.add_module(mysql)
+        services.add_module(auth)
+        services.add_module(permission)
 
         services.add_transient(DataAccessObjectABC, UserDao)
         services.add_transient(DataAccessObjectABC, CityDao)

example/custom/di/cpl-workspace.json

@@ -0,0 +1,9 @@
+{
+  "Workspace": {
+    "DefaultProject": "di",
+    "Projects": {
+      "di": "src/di/di.json"
+    },
+    "Scripts": {}
+  }
+}

example/custom/di/src/di/application.py

@@ -0,0 +1,42 @@
+from cpl.application.abc import ApplicationABC
+from cpl.core.console.console import Console
+from cpl.dependency import ServiceProviderABC
+from cpl.dependency.scope import Scope
+from di.static_test import StaticTest
+from di.test_abc import TestABC
+from di.test_service import TestService
+from di.di_tester_service import DITesterService
+from di.tester import Tester
+
+
+class Application(ApplicationABC):
+    def __init__(self, services: ServiceProviderABC):
+        ApplicationABC.__init__(self, services)
+
+    def _part_of_scoped(self):
+        ts: TestService = self._services.get_service(TestService)
+        ts.run()
+
+    def configure(self): ...
+
+    def main(self):
+        with self._services.create_scope() as scope:
+            Console.write_line("Scope1")
+            ts: TestService = scope.service_provider.get_service(TestService)
+            ts.run()
+            dit: DITesterService = scope.service_provider.get_service(DITesterService)
+            dit.run()
+
+        with self._services.create_scope() as scope:
+            Console.write_line("Scope2")
+            ts: TestService = scope.service_provider.get_service(TestService)
+            ts.run()
+            dit: DITesterService = scope.service_provider.get_service(DITesterService)
+            dit.run()
+
+        Console.write_line("Global")
+        self._part_of_scoped()
+        StaticTest.test()
+
+        self._services.get_service(Tester)
+        Console.write_line(self._services.get_services(list[TestABC]))

example/custom/di/src/di/di_tester_service.py

@@ -1,15 +1,11 @@
 from cpl.core.console.console import Console
-from test_service import TestService
+from di.test_service import TestService
 
 
 class DITesterService:
     def __init__(self, ts: TestService):
         self._ts = ts
 
-    @property
-    def name(self) -> str:
-        return self._ts.name
-
     def run(self):
         Console.write_line("DIT: ")
         self._ts.run()

example/custom/di/src/di/main.py

@@ -1,7 +1,7 @@
 from cpl.application import ApplicationBuilder
 
-from application import Application
-from startup import Startup
+from di.application import Application
+from di.startup import Startup
 
 
 def main():

example/custom/di/src/di/startup.py

@@ -0,0 +1,25 @@
+from cpl.application.abc import StartupABC
+from cpl.dependency import ServiceProviderABC, ServiceCollection
+from di.di_tester_service import DITesterService
+from di.test1_service import Test1Service
+from di.test2_service import Test2Service
+from di.test_abc import TestABC
+from di.test_service import TestService
+from di.tester import Tester
+
+
+class Startup(StartupABC):
+    def __init__(self):
+        StartupABC.__init__(self)
+
+    def configure_configuration(self): ...
+
+    def configure_services(self, services: ServiceCollection) -> ServiceProviderABC:
+        services.add_scoped(TestService)
+        services.add_scoped(DITesterService)
+
+        services.add_singleton(TestABC, Test1Service)
+        services.add_singleton(TestABC, Test2Service)
+        services.add_singleton(Tester)
+
+        return services.build()

example/custom/di/src/di/static_test.py

@@ -0,0 +1,9 @@
+from cpl.dependency import ServiceProvider, ServiceProviderABC
+from di.test_service import TestService
+
+
+class StaticTest:
+    @staticmethod
+    @ServiceProvider.inject
+    def test(services: ServiceProviderABC, t1: TestService):
+        t1.run()

example/custom/di/src/di/test1_service.py

@@ -1,12 +1,12 @@
 import string
 from cpl.core.console.console import Console
 from cpl.core.utils.string import String
-from test_abc import TestABC
+from di.test_abc import TestABC
 
 
 class Test1Service(TestABC):
     def __init__(self):
-        TestABC.__init__(self, String.random(8))
+        TestABC.__init__(self, String.random_string(string.ascii_lowercase, 8))
 
     def run(self):
         Console.write_line(f"Im {self._name}")

example/custom/di/src/di/test2_service.py

@@ -1,12 +1,12 @@
 import string
 from cpl.core.console.console import Console
 from cpl.core.utils.string import String
-from test_abc import TestABC
+from di.test_abc import TestABC
 
 
 class Test2Service(TestABC):
     def __init__(self):
-        TestABC.__init__(self, String.random(8))
+        TestABC.__init__(self, String.random_string(string.ascii_lowercase, 8))
 
     def run(self):
         Console.write_line(f"Im {self._name}")

example/custom/di/src/di/test_service.py

@@ -1,3 +1,5 @@
+import string
+
 from cpl.core.console.console import Console
 from cpl.core.utils.string import String
 
@@ -6,9 +8,5 @@ class TestService:
     def __init__(self):
         self._name = String.random(8)
 
-    @property
-    def name(self) -> str:
-        return self._name
-
     def run(self):
         Console.write_line(f"Im {self._name}")

example/custom/di/src/di/tester.py

@@ -0,0 +1,8 @@
+from cpl.core.console.console import Console
+from di.test_abc import TestABC
+
+
+class Tester:
+    def __init__(self, t1: TestABC, t2: TestABC, t3: list[TestABC]):
+        Console.write_line("Tester:")
+        Console.write_line(t1, t2, t3)

example/custom/general/cpl-workspace.json

@@ -0,0 +1,8 @@
+{
+  "Workspace": {
+    "DefaultProject": "general",
+    "Projects": {
+      "general": "src/general/general.json"
+    }
+  }
+}

example/custom/general/src/general/application.py

@@ -1,22 +1,22 @@
 import time
+from typing import Optional
 
 from cpl.application.abc import ApplicationABC
 from cpl.core.configuration import Configuration
 from cpl.core.console import Console
+from cpl.dependency import ServiceProviderABC
 from cpl.core.environment import Environment
 from cpl.core.log import LoggerABC
 from cpl.core.pipes import IPAddressPipe
-from cpl.dependency import ServiceProvider
 from cpl.mail import EMail, EMailClientABC
-from cpl.query import List
-from scoped_service import ScopedService
+from cpl.query.extension.list import List
 from test_service import TestService
 from test_settings import TestSettings
 
 
 class Application(ApplicationABC):
 
-    def __init__(self, services: ServiceProvider):
+    def __init__(self, services: ServiceProviderABC):
         ApplicationABC.__init__(self, services)
         self._logger = self._services.get_service(LoggerABC)
         self._mailer = self._services.get_service(EMailClientABC)
@@ -38,7 +38,7 @@ class Application(ApplicationABC):
     def main(self):
         self._logger.debug(f"Host: {Environment.get_host_name()}")
         self._logger.debug(f"Environment: {Environment.get_environment()}")
-        Console.write_line(List(range(0, 10)).select(lambda x: f"x={x}").to_list())
+        Console.write_line(List(int, range(0, 10)).select(lambda x: f"x={x}").to_list())
         Console.spinner("Test", self._wait, 2, spinner_foreground_color="red")
         test: TestService = self._services.get_service(TestService)
         ip_pipe: IPAddressPipe = self._services.get_service(IPAddressPipe)
@@ -48,21 +48,10 @@ class Application(ApplicationABC):
         Console.write_line(f"DI working: {test == test2 and ip_pipe != ip_pipe2}")
         Console.write_line(self._services.get_service(LoggerABC))
 
-        root_scoped_service = self._services.get_service(ScopedService)
-        with self._services.create_scope() as scope:
-            s_srvc1 = scope.get_service(ScopedService)
-            s_srvc2 = scope.get_service(ScopedService)
-
-            Console.write_line(root_scoped_service)
-            Console.write_line(s_srvc1)
-            Console.write_line(s_srvc2)
-            if root_scoped_service == s_srvc1 or s_srvc1 != s_srvc2:
-                raise Exception("Root scoped service should not be equal to scoped service")
-
-        root_scoped_service2 = self._services.get_service(ScopedService)
-        Console.write_line(root_scoped_service2)
-        if root_scoped_service == root_scoped_service2:
-            raise Exception("Root scoped service should be equal to root scoped service 2")
+        scope = self._services.create_scope()
+        Console.write_line("scope", scope)
+        with self._services.create_scope() as s:
+            Console.write_line("with scope", s)
 
         test_settings = Configuration.get(TestSettings)
         Console.write_line(test_settings.value)
@@ -73,9 +62,3 @@ class Application(ApplicationABC):
         test_settings1 = Configuration.get(TestSettings)
         Console.write_line(test_settings1.value)
         # self.test_send_mail()
-
-        x = 0
-        while x < 5:
-            Console.write_line("Running...")
-            x += 1
-            time.sleep(5)

example/custom/general/src/general/general.json

@@ -0,0 +1,51 @@
+{
+  "Project": {
+    "Name": "general",
+    "Version": {
+      "Major": "2021",
+      "Minor": "04",
+      "Micro": "01"
+    },
+    "Author": "Sven Heidemann",
+    "AuthorEmail": "sven.heidemann@sh-edraft.de",
+    "Description": "sh-edraft Common Python library",
+    "LongDescription": "sh-edraft Common Python library",
+    "URL": "https://www.sh-edraft.de",
+    "CopyrightDate": "2020 - 2021",
+    "CopyrightName": "sh-edraft.de",
+    "LicenseName": "MIT",
+    "LicenseDescription": "MIT, see LICENSE for more details.",
+    "Dependencies": [
+      "cpl-core==2022.10.0.post9",
+      "cpl-translation==2022.10.0.post2",
+      "cpl-query==2022.10.0.post2"
+    ],
+    "DevDependencies": [
+      "cpl-cli==2022.10"
+    ],
+    "PythonVersion": ">=3.10",
+    "PythonPath": {
+      "linux": "../../venv/bin/python",
+      "win32": ""
+    },
+    "Classifiers": []
+  },
+  "Build": {
+    "ProjectType": "console",
+    "SourcePath": "",
+    "OutputPath": "dist",
+    "Main": "main",
+    "EntryPoint": "",
+    "IncludePackageData": true,
+    "Included": [
+      "*/templates"
+    ],
+    "Excluded": [
+      "*/__pycache__",
+      "*/logs",
+      "*/tests"
+    ],
+    "PackageData": {},
+    "ProjectReferences": []
+  }
+}

example/custom/general/src/general/startup.py

@@ -4,9 +4,6 @@ from cpl.core.configuration import Configuration
 from cpl.core.environment import Environment
 from cpl.core.pipes import IPAddressPipe
 from cpl.dependency import ServiceCollection
-from cpl.mail.mail_module import MailModule
-from hosted_service import Hosted
-from scoped_service import ScopedService
 from test_service import TestService
 
 
@@ -21,8 +18,6 @@ class Startup(StartupABC):
     @staticmethod
     def configure_services(services: ServiceCollection):
         services.add_logging()
-        services.add_module(MailModule)
+        services.add_module(mail)
         services.add_transient(IPAddressPipe)
         services.add_singleton(TestService)
-        services.add_scoped(ScopedService)
-        services.add_hosted_service(Hosted)

example/custom/general/src/general/test_extension.py

@@ -1,10 +1,10 @@
 from cpl.application.abc import ApplicationExtensionABC
 from cpl.core.console import Console
-from cpl.dependency import ServiceProvider
+from cpl.dependency import ServiceProviderABC
 
 
 class TestExtension(ApplicationExtensionABC):
 
     @staticmethod
-    def run(services: ServiceProvider):
+    def run(services: ServiceProviderABC):
         Console.write_line("Hello World from App Extension")

example/custom/general/src/general/test_service.py

@@ -1,10 +1,10 @@
 from cpl.core.console.console import Console
-from cpl.dependency import ServiceProvider
+from cpl.dependency import ServiceProviderABC
 from cpl.core.pipes.ip_address_pipe import IPAddressPipe
 
 
 class TestService:
-    def __init__(self, provider: ServiceProvider):
+    def __init__(self, provider: ServiceProviderABC):
         self._provider = provider
 
     def run(self):

example/custom/general/test/custom.py

@@ -0,0 +1,3 @@
+class Custom:
+    def __init__(self):
+        print("hello")

example/custom/query/main.py

@@ -48,9 +48,9 @@ def t_benchmark(data: list):
 
 
 def main():
-    N = 1_000_000
+    N = 10_000_000
     data = list(range(N))
-    t_benchmark(data)
+    #t_benchmark(data)
 
     Console.write_line()
     _default()

example/custom/translation/src/translation/application.py

@@ -1,14 +1,14 @@
 from cpl.application import ApplicationABC
 from cpl.core.configuration import ConfigurationABC
 from cpl.core.console import Console
-from cpl.dependency import ServiceProvider
+from cpl.dependency import ServiceProviderABC
 from cpl.translation.translate_pipe import TranslatePipe
 from cpl.translation.translation_service_abc import TranslationServiceABC
 from cpl.translation.translation_settings import TranslationSettings
 
 
 class Application(ApplicationABC):
-    def __init__(self, config: ConfigurationABC, services: ServiceProvider):
+    def __init__(self, config: ConfigurationABC, services: ServiceProviderABC):
         ApplicationABC.__init__(self, config, services)
 
         self._translate: TranslatePipe = services.get_service(TranslatePipe)

example/custom/translation/src/translation/startup.py

@@ -1,6 +1,6 @@
 from cpl.application import StartupABC
 from cpl.core.configuration import ConfigurationABC
-from cpl.dependency import ServiceProvider, ServiceCollection
+from cpl.dependency import ServiceProviderABC, ServiceCollection
 from cpl.core.environment import Environment
 
 
@@ -12,6 +12,6 @@ class Startup(StartupABC):
         configuration.add_json_file("appsettings.json")
         return configuration
 
-    def configure_services(self, services: ServiceCollection, environment: Environment) -> ServiceProvider:
+    def configure_services(self, services: ServiceCollection, environment: Environment) -> ServiceProviderABC:
         services.add_translation()
         return services.build()

example/di/src/application.py

@@ -1,45 +0,0 @@
-from cpl.application.abc import ApplicationABC
-from cpl.core.console.console import Console
-from cpl.dependency import ServiceProvider
-from test_abc import TestABC
-from test_service import TestService
-from di_tester_service import DITesterService
-from tester import Tester
-
-
-class Application(ApplicationABC):
-    def __init__(self, services: ServiceProvider):
-        ApplicationABC.__init__(self, services)
-
-    def _part_of_scoped(self):
-        ts: TestService = self._services.get_service(TestService)
-        ts.run()
-
-    def main(self):
-        with self._services.create_scope() as scope:
-            Console.write_line("Scope1")
-            ts: TestService = scope.get_service(TestService)
-            ts.run()
-            dit: DITesterService = scope.get_service(DITesterService)
-            dit.run()
-
-            if ts.name != dit.name:
-                raise Exception("DI is broken!")
-
-        with self._services.create_scope() as scope:
-            Console.write_line("Scope2")
-            ts: TestService = scope.get_service(TestService)
-            ts.run()
-            dit: DITesterService = scope.get_service(DITesterService)
-            dit.run()
-
-            if ts.name != dit.name:
-                raise Exception("DI is broken!")
-
-        Console.write_line("Global")
-        self._part_of_scoped()
-        #from static_test import StaticTest
-        #StaticTest.test()
-
-        self._services.get_service(Tester)
-        Console.write_line(self._services.get_services(TestABC))

example/di/src/startup.py

@@ -1,27 +0,0 @@
-from cpl.application.abc import StartupABC
-from cpl.dependency import ServiceProvider, ServiceCollection
-from di_tester_service import DITesterService
-from test1_service import Test1Service
-from test2_service import Test2Service
-from test_abc import TestABC
-from test_service import TestService
-from tester import Tester
-
-
-class Startup(StartupABC):
-    def __init__(self):
-        StartupABC.__init__(self)
-
-    @staticmethod
-    def configure_configuration(): ...
-
-    @staticmethod
-    def configure_services(services: ServiceCollection) -> ServiceProvider:
-        services.add_scoped(TestService)
-        services.add_scoped(DITesterService)
-
-        services.add_singleton(TestABC, Test1Service)
-        services.add_singleton(TestABC, Test2Service)
-        services.add_singleton(Tester)
-
-        return services.build()

example/di/src/static_test.py

@@ -1,10 +0,0 @@
-from cpl.dependency import ServiceProvider, ServiceProvider
-from cpl.dependency.inject import inject
-from test_service import TestService
-
-
-class StaticTest:
-    @staticmethod
-    @inject
-    def test(services: ServiceProvider, t1: TestService):
-        t1.run()

example/di/src/tester.py

@@ -1,7 +0,0 @@
-from cpl.core.console.console import Console
-from test_abc import TestABC
-
-
-class Tester:
-    def __init__(self, t1: TestABC, t2: TestABC, t3: TestABC, t: list[TestABC]):
-        Console.write_line("Tester:", t, t1, t2, t3)

example/general/src/hosted_service.py

@@ -1,20 +0,0 @@
-import asyncio
-import time
-
-from cpl.core.console import Console
-from cpl.dependency.hosted.hosted_service import HostedService
-
-
-class Hosted(HostedService):
-    def __init__(self):
-        self._stopped = False
-
-    async def start(self):
-        Console.write_line("Hosted Service Started")
-        while not self._stopped:
-            Console.write_line("Hosted Service Running")
-            await asyncio.sleep(5)
-
-    async def stop(self):
-        Console.write_line("Hosted Service Stopped")
-        self._stopped = True

example/general/src/scoped_service.py

@@ -1,10 +0,0 @@
-from cpl.core.console import Console
-
-
-class ScopedService:
-    def __init__(self):
-        self.value = "I am a scoped service"
-        Console.write_line(self.value, self)
-
-    def get_value(self):
-        return self.value

src/cpl-api/cpl/api/__init__.py

@@ -1,4 +1,36 @@
+from cpl.dependency.service_collection import ServiceCollection as _ServiceCollection
+
 from .error import APIError, AlreadyExists, EndpointNotImplemented, Forbidden, NotFound, Unauthorized
 from .logger import APILogger
 from .settings import ApiSettings
-from .api_module import ApiModule
+
+
+def add_api(collection: _ServiceCollection):
+    try:
+        from cpl.database import mysql
+
+        collection.add_module(mysql)
+    except ImportError as e:
+        from cpl.core.errors import dependency_error
+
+        dependency_error("cpl-database", e)
+
+    try:
+        from cpl import auth
+        from cpl.auth import permission
+
+        collection.add_module(auth)
+        collection.add_module(permission)
+    except ImportError as e:
+        from cpl.core.errors import dependency_error
+
+        dependency_error("cpl-auth", e)
+
+    from cpl.api.registry.policy import PolicyRegistry
+    from cpl.api.registry.route import RouteRegistry
+
+    collection.add_singleton(PolicyRegistry)
+    collection.add_singleton(RouteRegistry)
+
+
+_ServiceCollection.with_module(add_api, __name__)

src/cpl-api/cpl/api/api_module.py

@@ -1,22 +0,0 @@
-from cpl.api import ApiSettings
-from cpl.api.registry.policy import PolicyRegistry
-from cpl.api.registry.route import RouteRegistry
-from cpl.auth.auth_module import AuthModule
-from cpl.auth.permission.permission_module import PermissionsModule
-from cpl.database.database_module import DatabaseModule
-from cpl.dependency import ServiceCollection
-from cpl.dependency.module.module import Module
-
-
-class ApiModule(Module):
-    config = [ApiSettings]
-    singleton = [
-        PolicyRegistry,
-        RouteRegistry,
-    ]
-
-    @staticmethod
-    def register(collection: ServiceCollection):
-        collection.add_module(DatabaseModule)
-        collection.add_module(AuthModule)
-        collection.add_module(PermissionsModule)

src/cpl-api/cpl/api/application/web_app.py

@@ -10,7 +10,7 @@ from starlette.requests import Request
 from starlette.responses import JSONResponse
 from starlette.types import ExceptionHandler
 
-from cpl.api.api_module import ApiModule
+from cpl import api, auth
 from cpl.api.error import APIError
 from cpl.api.logger import APILogger
 from cpl.api.middleware.authentication import AuthenticationMiddleware
@@ -26,19 +26,16 @@ from cpl.api.router import Router
 from cpl.api.settings import ApiSettings
 from cpl.api.typing import HTTPMethods, PartialMiddleware, PolicyResolver
 from cpl.application.abc.application_abc import ApplicationABC
-from cpl.auth.auth_module import AuthModule
-from cpl.auth.permission.permission_module import PermissionsModule
-from cpl.core.configuration.configuration import Configuration
-from cpl.dependency.inject import inject
-from cpl.dependency.service_provider import ServiceProvider
-from cpl.dependency.typing import Modules
+from cpl.core.configuration import Configuration
+from cpl.dependency.service_provider_abc import ServiceProviderABC
+
 
 PolicyInput = Union[dict[str, PolicyResolver], Policy]
 
 
 class WebApp(ApplicationABC):
-    def __init__(self, services: ServiceProvider, modules: Modules):
-        super().__init__(services, modules, [AuthModule, PermissionsModule, ApiModule])
+    def __init__(self, services: ServiceProviderABC):
+        super().__init__(services, [auth, api])
         self._app: Starlette | None = None
 
         self._logger = services.get_service(APILogger)
@@ -47,15 +44,15 @@ class WebApp(ApplicationABC):
         self._policies = services.get_service(PolicyRegistry)
         self._routes = services.get_service(RouteRegistry)
 
-        self._middleware: list[Middleware] = []
+        self._middleware: list[Middleware] = [
+            Middleware(RequestMiddleware),
+            Middleware(LoggingMiddleware),
+        ]
         self._exception_handlers: Mapping[Any, ExceptionHandler] = {
             Exception: self._handle_exception,
             APIError: self._handle_exception,
         }
 
-        self.with_middleware(RequestMiddleware)
-        self.with_middleware(LoggingMiddleware)
-
     async def _handle_exception(self, request: Request, exc: Exception):
         if isinstance(exc, APIError):
             self._logger.error(exc)
@@ -78,6 +75,11 @@ class WebApp(ApplicationABC):
         self._logger.debug(f"Allowed origins: {origins}")
         return origins.split(",")
 
+    def with_database(self) -> Self:
+        self.with_migrations()
+        self.with_seeders()
+        return self
+
     def with_app(self, app: Starlette) -> Self:
         assert app is not None, "app must not be None"
         assert isinstance(app, Starlette), "app must be an instance of Starlette"
@@ -166,9 +168,9 @@ class WebApp(ApplicationABC):
         self._check_for_app()
 
         if isinstance(middleware, Middleware):
-            self._middleware.append(inject(middleware))
+            self._middleware.append(middleware)
         elif callable(middleware):
-            self._middleware.append(Middleware(inject(middleware)))
+            self._middleware.append(Middleware(middleware))
         else:
             raise ValueError("middleware must be of type starlette.middleware.Middleware or a callable")
 
@@ -218,7 +220,7 @@ class WebApp(ApplicationABC):
         self._validate_policies()
 
         if self._app is None:
-            routes = [route.to_starlette(inject) for route in self._routes.all()]
+            routes = [route.to_starlette(self._services.inject) for route in self._routes.all()]
 
             app = Starlette(
                 routes=routes,

src/cpl-api/cpl/api/middleware/authentication.py

@@ -9,10 +9,12 @@ from cpl.api.router import Router
 from cpl.auth.keycloak import KeycloakClient
 from cpl.auth.schema import AuthUserDao, AuthUser
 from cpl.core.ctx import set_user
+from cpl.dependency import ServiceProviderABC
 
 
 class AuthenticationMiddleware(ASGIMiddleware):
 
+    @ServiceProviderABC.inject
     def __init__(self, app, logger: APILogger, keycloak: KeycloakClient, user_dao: AuthUserDao):
         ASGIMiddleware.__init__(self, app)
 

src/cpl-api/cpl/api/middleware/authorization.py

@@ -9,10 +9,12 @@ from cpl.api.registry.policy import PolicyRegistry
 from cpl.api.router import Router
 from cpl.auth.schema._administration.auth_user_dao import AuthUserDao
 from cpl.core.ctx.user_context import get_user
+from cpl.dependency.service_provider_abc import ServiceProviderABC
 
 
 class AuthorizationMiddleware(ASGIMiddleware):
 
+    @ServiceProviderABC.inject
     def __init__(self, app, logger: APILogger, policies: PolicyRegistry, user_dao: AuthUserDao):
         ASGIMiddleware.__init__(self, app)
 

src/cpl-api/cpl/api/middleware/logging.py

@@ -6,10 +6,12 @@ from starlette.types import Receive, Scope, Send
 from cpl.api.abc.asgi_middleware_abc import ASGIMiddleware
 from cpl.api.logger import APILogger
 from cpl.api.middleware.request import get_request
+from cpl.dependency import ServiceProviderABC
 
 
 class LoggingMiddleware(ASGIMiddleware):
 
+    @ServiceProviderABC.inject
     def __init__(self, app, logger: APILogger):
         ASGIMiddleware.__init__(self, app)
 

src/cpl-api/cpl/api/middleware/request.py

@@ -9,18 +9,17 @@ from starlette.types import Scope, Receive, Send
 from cpl.api.abc.asgi_middleware_abc import ASGIMiddleware
 from cpl.api.logger import APILogger
 from cpl.api.typing import TRequest
-from cpl.dependency.inject import inject
-from cpl.dependency.service_provider import ServiceProvider
+from cpl.dependency import ServiceProviderABC
 
 _request_context: ContextVar[Union[TRequest, None]] = ContextVar("request", default=None)
 
 
 class RequestMiddleware(ASGIMiddleware):
 
-    def __init__(self, app, provider: ServiceProvider, logger: APILogger):
+    @ServiceProviderABC.inject
+    def __init__(self, app, logger: APILogger):
         ASGIMiddleware.__init__(self, app)
 
-        self._provider = provider
         self._logger = logger
 
         self._ctx_token = None
@@ -30,8 +29,7 @@ class RequestMiddleware(ASGIMiddleware):
         await self.set_request_data(request)
 
         try:
-            with self._provider.create_scope():
-                inject(await self._app(scope, receive, send))
+            await self._app(scope, receive, send)
         finally:
             await self.clean_request_data()
 

src/cpl-api/cpl/api/router.py

@@ -3,7 +3,6 @@ from enum import Enum
 from cpl.api.model.validation_match import ValidationMatch
 from cpl.api.registry.route import RouteRegistry
 from cpl.api.typing import HTTPMethods
-from cpl.dependency import get_provider
 
 
 class Router:
@@ -96,7 +95,9 @@ class Router:
         from cpl.api.model.api_route import ApiRoute
 
         if not registry:
-            routes = get_provider().get_service(RouteRegistry)
+            from cpl.dependency.service_provider_abc import ServiceProviderABC
+
+            routes = ServiceProviderABC.get_global_service(RouteRegistry)
         else:
             routes = registry
 
@@ -143,8 +144,9 @@ class Router:
         """
 
         from cpl.api.model.api_route import ApiRoute
+        from cpl.dependency.service_provider_abc import ServiceProviderABC
 
-        routes = get_provider().get_service(RouteRegistry)
+        routes = ServiceProviderABC.get_global_service(RouteRegistry)
 
         def inner(fn):
             path = getattr(fn, "_route_path", None)

src/cpl-application/cpl/application/__init__.py

@@ -1,2 +1 @@
 from .application_builder import ApplicationBuilder
-from .host import Host

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

@@ -2,12 +2,10 @@ 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
+from cpl.dependency.service_provider_abc import ServiceProviderABC
 
 
 def __not_implemented__(package: str, func: Callable):
@@ -18,10 +16,21 @@ class ApplicationABC(ABC):
     r"""ABC for the Application class
 
     Parameters:
-        services: :class:`cpl.dependency.service_provider.ServiceProvider`
+        services: :class:`cpl.dependency.service_provider_abc.ServiceProviderABC`
             Contains instances of prepared objects
     """
 
+    @abstractmethod
+    def __init__(self, services: ServiceProviderABC, required_modules: list[str | object] = None):
+        self._services = services
+        self._required_modules = (
+            [x.__name__ if not isinstance(x, str) else x for x in required_modules] if required_modules else []
+        )
+
+    @property
+    def required_modules(self) -> list[str]:
+        return self._required_modules
+
     @classmethod
     def extend(cls, name: str | Callable, func: Callable[[Self], Self]):
         r"""Extend the Application with a custom method
@@ -38,30 +47,6 @@ class ApplicationABC(ABC):
         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
@@ -72,21 +57,14 @@ class ApplicationABC(ABC):
         logger = self._services.get_service(LoggerABC)
         logger.set_level(level)
 
-    def with_permissions(self, *args):
-        try:
-            from cpl.auth import AuthModule
+    def with_permissions(self, *args, **kwargs):
+        __not_implemented__("cpl-auth", self.with_permissions)
 
-            AuthModule.with_permissions(*args)
-        except ImportError:
-            __not_implemented__("cpl-auth", self.with_permissions)
+    def with_migrations(self, *args, **kwargs):
+        __not_implemented__("cpl-database", self.with_migrations)
 
-    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_seeders(self, *args, **kwargs):
+        __not_implemented__("cpl-database", self.with_seeders)
 
     def with_extension(self, func: Callable[[Self, ...], None], *args, **kwargs):
         r"""Extend the Application with a custom method
@@ -106,12 +84,7 @@ class ApplicationABC(ABC):
         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)
+            Host.run(self.main)
         except KeyboardInterrupt:
             pass
 

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

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

src/cpl-application/cpl/application/application_builder.py

@@ -7,7 +7,6 @@ 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.core.errors import dependency_error
-from cpl.dependency.context import get_provider, use_root_provider
 from cpl.dependency.service_collection import ServiceCollection
 
 TApp = TypeVar("TApp", bound=ApplicationABC)
@@ -22,7 +21,6 @@ class ApplicationBuilder(Generic[TApp]):
         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]] = []
@@ -36,12 +34,19 @@ class ApplicationBuilder(Generic[TApp]):
 
     @property
     def service_provider(self):
-        provider = get_provider()
-        if provider is None:
-            provider = self._services.build()
-            use_root_provider(provider)
+        return self._services.build()
 
-        return provider
+    def validate_app_required_modules(self, app: ApplicationABC):
+        for module in app.required_modules:
+            if module in self._services.loaded_modules:
+                continue
+
+            dependency_error(
+                module,
+                ImportError(
+                    f"Required module '{module}' for application '{app.__class__.__name__}' is not loaded. Load using 'add_module({module})' method."
+                ),
+            )
 
     def with_startup(self, startup: Type[StartupABC]) -> "ApplicationBuilder":
         self._startup = startup
@@ -70,7 +75,6 @@ class ApplicationBuilder(Generic[TApp]):
         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()
+        app = self._app(self.service_provider)
+        self.validate_app_required_modules(app)
         return app

src/cpl-application/cpl/application/host.py

@@ -1,80 +1,17 @@
 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 = {}
+    _loop = asyncio.get_event_loop()
 
     @classmethod
-    def get_loop(cls) -> asyncio.AbstractEventLoop:
-        if cls._loop is None:
-            cls._loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(cls._loop)
+    def get_loop(cls):
         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):
-                    app_task = asyncio.create_task(func(*args, **kwargs))
-                else:
-                    app_task = cls.get_loop().run_in_executor(None, func, *args, **kwargs)
-
-                await asyncio.wait(
-                    [app_task, *cls._tasks.values()],
-                    return_when=asyncio.FIRST_COMPLETED,
-                )
-            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 cls._loop.run_until_complete(func(*args, **kwargs))
 
         return func(*args, **kwargs)

src/cpl-auth/cpl/auth/__init__.py

@@ -1,6 +1,84 @@
+from enum import Enum
+from typing import Type
+
+from cpl.application.abc import ApplicationABC as _ApplicationABC
 from cpl.auth import permission as _permission
 from cpl.auth.keycloak.keycloak_admin import KeycloakAdmin as _KeycloakAdmin
 from cpl.auth.keycloak.keycloak_client import KeycloakClient as _KeycloakClient
-from .auth_module import AuthModule
-from .keycloak_settings import KeycloakSettings
+from cpl.dependency.service_collection import ServiceCollection as _ServiceCollection
 from .logger import AuthLogger
+from .keycloak_settings import KeycloakSettings
+from .permission_seeder import PermissionSeeder
+
+
+def _with_permissions(self: _ApplicationABC, *permissions: Type[Enum]) -> _ApplicationABC:
+    from cpl.auth.permission.permissions_registry import PermissionsRegistry
+
+    for perm in permissions:
+        PermissionsRegistry.with_enum(perm)
+    return self
+
+
+def _add_daos(collection: _ServiceCollection):
+    from .schema._administration.auth_user_dao import AuthUserDao
+    from .schema._administration.api_key_dao import ApiKeyDao
+    from .schema._permission.api_key_permission_dao import ApiKeyPermissionDao
+    from .schema._permission.permission_dao import PermissionDao
+    from .schema._permission.role_dao import RoleDao
+    from .schema._permission.role_permission_dao import RolePermissionDao
+    from .schema._permission.role_user_dao import RoleUserDao
+
+    collection.add_singleton(AuthUserDao)
+    collection.add_singleton(ApiKeyDao)
+    collection.add_singleton(ApiKeyPermissionDao)
+    collection.add_singleton(PermissionDao)
+    collection.add_singleton(RoleDao)
+    collection.add_singleton(RolePermissionDao)
+    collection.add_singleton(RoleUserDao)
+
+
+def add_auth(collection: _ServiceCollection):
+    import os
+
+    try:
+        from cpl.database.service.migration_service import MigrationService
+        from cpl.database.model.server_type import ServerType, ServerTypes
+
+        collection.add_singleton(_KeycloakClient)
+        collection.add_singleton(_KeycloakAdmin)
+
+        _add_daos(collection)
+
+        provider = collection.build()
+        migration_service: MigrationService = provider.get_service(MigrationService)
+        if ServerType.server_type == ServerTypes.POSTGRES:
+            migration_service.with_directory(
+                os.path.join(os.path.dirname(os.path.realpath(__file__)), "scripts/postgres")
+            )
+        elif ServerType.server_type == ServerTypes.MYSQL:
+            migration_service.with_directory(os.path.join(os.path.dirname(os.path.realpath(__file__)), "scripts/mysql"))
+    except ImportError as e:
+        from cpl.core.console import Console
+
+        Console.error("cpl-database is not installed", str(e))
+
+
+def add_permission(collection: _ServiceCollection):
+    from .permission_seeder import PermissionSeeder
+    from .permission.permissions_registry import PermissionsRegistry
+    from .permission.permissions import Permissions
+
+    try:
+        from cpl.database.abc.data_seeder_abc import DataSeederABC
+
+        collection.add_singleton(DataSeederABC, PermissionSeeder)
+        PermissionsRegistry.with_enum(Permissions)
+    except ImportError as e:
+        from cpl.core.console import Console
+
+        Console.error("cpl-database is not installed", str(e))
+
+
+_ServiceCollection.with_module(add_auth, __name__)
+_ServiceCollection.with_module(add_permission, _permission.__name__)
+_ApplicationABC.extend(_ApplicationABC.with_permissions, _with_permissions)

src/cpl-auth/cpl/auth/auth_module.py

@@ -1,56 +0,0 @@
-import os
-from enum import Enum
-from typing import Type
-
-from cpl.auth.keycloak_settings import KeycloakSettings
-from cpl.database.database_module import DatabaseModule
-from cpl.database.model.server_type import ServerType, ServerTypes
-from cpl.database.mysql.mysql_module import MySQLModule
-from cpl.database.postgres.postgres_module import PostgresModule
-from cpl.dependency.module.module import Module
-from cpl.dependency.service_provider import ServiceProvider
-from .keycloak.keycloak_admin import KeycloakAdmin
-from .keycloak.keycloak_client import KeycloakClient
-from .schema._administration.api_key_dao import ApiKeyDao
-from .schema._administration.auth_user_dao import AuthUserDao
-from .schema._permission.api_key_permission_dao import ApiKeyPermissionDao
-from .schema._permission.permission_dao import PermissionDao
-from .schema._permission.role_dao import RoleDao
-from .schema._permission.role_permission_dao import RolePermissionDao
-from .schema._permission.role_user_dao import RoleUserDao
-
-
-class AuthModule(Module):
-    dependencies = [DatabaseModule, (MySQLModule, PostgresModule)]
-    config = [KeycloakSettings]
-    singleton = [
-        KeycloakClient,
-        KeycloakAdmin,
-        AuthUserDao,
-        ApiKeyDao,
-        ApiKeyPermissionDao,
-        PermissionDao,
-        RoleDao,
-        RolePermissionDao,
-        RoleUserDao,
-    ]
-    scoped = []
-    transient = []
-
-    @staticmethod
-    def configure(provider: ServiceProvider):
-        paths = {
-            ServerTypes.POSTGRES: "scripts/postgres",
-            ServerTypes.MYSQL: "scripts/mysql",
-        }
-
-        DatabaseModule.with_migrations(
-            provider, str(os.path.join(os.path.dirname(os.path.realpath(__file__)), paths[ServerType.server_type]))
-        )
-
-    @staticmethod
-    def with_permissions(*permissions: Type[Enum]):
-        from cpl.auth.permission.permissions_registry import PermissionsRegistry
-
-        for perm in permissions:
-            PermissionsRegistry.with_enum(perm)

src/cpl-auth/cpl/auth/keycloak/keycloak_user.py

@@ -1,5 +1,5 @@
 from cpl.core.utils.get_value import get_value
-from cpl.dependency import ServiceProvider
+from cpl.dependency import ServiceProviderABC
 
 
 class KeycloakUser:
@@ -32,5 +32,5 @@ class KeycloakUser:
     def id(self) -> str:
         from cpl.auth import KeycloakAdmin
 
-        keycloak_admin: KeycloakAdmin = get_provider().get_service(KeycloakAdmin)
+        keycloak_admin: KeycloakAdmin = ServiceProviderABC.get_global_service(KeycloakAdmin)
         return keycloak_admin.get_user_id(self._username)