Fixed test action installation

Reviewed-on: #199

.gitea/workflows/build-dev.yaml

@@ -0,0 +1,83 @@
+name: Build on push
+run-name: Build on push
+on:
+  push:
+    branches:
+      - dev
+
+jobs:
+  prepare:
+    uses: ./.gitea/workflows/prepare.yaml
+    with:
+      version_suffix: 'dev'
+    secrets: inherit
+
+  api:
+    uses: ./.gitea/workflows/package.yaml
+    needs: [ prepare, application, auth, core, dependency ]
+    with:
+      working_directory: src/api
+    secrets: inherit
+
+  application:
+    uses: ./.gitea/workflows/package.yaml
+    needs: [ prepare, core, dependency ]
+    with:
+      working_directory: src/application
+    secrets: inherit
+
+  auth:
+    uses: ./.gitea/workflows/package.yaml
+    needs: [ prepare, core, dependency,  database ]
+    with:
+      working_directory: src/auth
+    secrets: inherit
+
+  cli:
+    uses: ./.gitea/workflows/package.yaml
+    needs: [ prepare, core ]
+    with:
+      working_directory: src/cli
+    secrets: inherit
+
+  core:
+    uses: ./.gitea/workflows/package.yaml
+    needs: [prepare]
+    with:
+      working_directory: src/core
+    secrets: inherit
+
+  database:
+    uses: ./.gitea/workflows/package.yaml
+    needs: [ prepare, core, dependency ]
+    with:
+      working_directory: src/database
+    secrets: inherit
+
+  dependency:
+    uses: ./.gitea/workflows/package.yaml
+    needs: [ prepare, core ]
+    with:
+      working_directory: src/dependency
+    secrets: inherit
+
+  mail:
+    uses: ./.gitea/workflows/package.yaml
+    needs: [ prepare, core, dependency ]
+    with:
+      working_directory: src/mail
+    secrets: inherit
+
+  query:
+    uses: ./.gitea/workflows/package.yaml
+    needs: [prepare]
+    with:
+      working_directory: src/query
+    secrets: inherit
+
+  translation:
+    uses: ./.gitea/workflows/package.yaml
+    needs: [ prepare, core, dependency ]
+    with:
+      working_directory: src/translation
+    secrets: inherit

.gitea/workflows/build.yaml

@@ -0,0 +1,39 @@
+name: Build on push
+run-name: Build on push
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  prepare:
+    uses: ./.gitea/workflows/prepare.yaml
+    secrets: inherit
+
+  core:
+    uses: ./.gitea/workflows/package.yaml
+    needs: [prepare]
+    with:
+      working_directory: src/cpl-core
+    secrets: inherit
+
+  query:
+    uses: ./.gitea/workflows/package.yaml
+    needs: [prepare]
+    with:
+      working_directory: src/cpl-query
+    secrets: inherit
+
+  translation:
+    uses: ./.gitea/workflows/package.yaml
+    needs: [ prepare, core ]
+    with:
+      working_directory: src/cpl-translation
+    secrets: inherit
+
+  mail:
+    uses: ./.gitea/workflows/package.yaml
+    needs: [ prepare, core ]
+    with:
+      working_directory: src/cpl-mail
+    secrets: inherit

.gitea/workflows/package.yaml

@@ -0,0 +1,71 @@
+name: Build Package
+run-name: Build Python Package
+
+on:
+  workflow_call:
+    inputs:
+      version_suffix:
+        description: 'Suffix for version (z.B. "dev", "alpha", "beta")'
+        required: false
+        type: string
+      working_directory:
+        required: true
+        type: string
+
+jobs:
+  build:
+    runs-on: [ runner ]
+    container: git.sh-edraft.de/sh-edraft.de/act-runner:latest
+    defaults:
+      run:
+        working-directory: ${{ inputs.working_directory }}
+    steps:
+      - name: Clone Repository
+        uses: https://github.com/actions/checkout@v3
+        with:
+          token: ${{ secrets.CI_ACCESS_TOKEN }}
+
+      - name: Download build version artifact
+        uses: actions/download-artifact@v3
+        with:
+          name: version
+
+      - name: Set version
+        run: |
+          sed -i -E "s/^version = \".*\"/version = \"$(cat /workspace/sh-edraft.de/cpl/version.txt)\"/" pyproject.toml
+          echo "Set version to $(cat /workspace/sh-edraft.de/cpl/version.txt)"
+          cat pyproject.toml
+
+      - name: Set package version
+        run: |
+          sed -i -E "s/^__version__ = \".*\"/__version__ = \"$(cat /workspace/sh-edraft.de/cpl/version.txt)\"/" cpl/*/__init__.py
+          echo "Set version to $(cat /workspace/sh-edraft.de/cpl/version.txt)"
+          cat cpl/*/__init__.py
+
+      - name: Set pip conf
+        run: |
+          cat > .pip.conf <<'EOF'
+          [global]
+          extra-index-url = https://git.sh-edraft.de/api/packages/sh-edraft.de/pypi/simple/
+          EOF
+
+      - name: Install Dependencies
+        run: |
+          export PIP_CONFIG_FILE=".pip.conf"
+          pip install build
+
+      - name: Build Package
+        run: |
+          python -m build --outdir dist
+
+      - name: Login to registry git.sh-edraft.de
+        uses: https://github.com/docker/login-action@v1
+        with:
+          registry: git.sh-edraft.de
+          username: ${{ secrets.CI_USERNAME }}
+          password: ${{ secrets.CI_ACCESS_TOKEN }}
+
+      - name: Push image
+        run: |
+          pip install twine
+          python -m twine upload --repository-url https://git.sh-edraft.de/api/packages/sh-edraft.de/pypi -u ${{ secrets.CI_USERNAME }} -p ${{ secrets.CI_ACCESS_TOKEN }} ./dist/*

.gitea/workflows/prepare.yaml

@@ -0,0 +1,58 @@
+name: Prepare Build
+run-name: Prepare Build Version
+
+on:
+  workflow_call:
+    inputs:
+      version_suffix:
+        description: 'Suffix for version (z.B. "dev", "alpha", "beta")'
+        required: false
+        type: string
+
+jobs:
+  prepare:
+    runs-on: [ runner ]
+    container: git.sh-edraft.de/sh-edraft.de/act-runner:latest
+    steps:
+      - name: Clone Repository
+        uses: https://github.com/actions/checkout@v3
+        with:
+          token: ${{ secrets.CI_ACCESS_TOKEN }}
+
+      - name: Get Date and Build Number
+        run: |
+          git fetch --tags
+          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
+          
+          VERSION_SUFFIX=${{ inputs.version_suffix }}
+          if [ -n "$VERSION_SUFFIX" ] && [ "$VERSION_SUFFIX" = "dev" ]; then
+            BUILD_VERSION="${DATE}.dev${BUILD_NUMBER}"
+          elif [ -n "$VERSION_SUFFIX" ]; then
+            BUILD_VERSION="${DATE}.${BUILD_NUMBER}${VERSION_SUFFIX}"
+          else
+            BUILD_VERSION="${DATE}.${BUILD_NUMBER}"
+          fi
+          
+          echo "$BUILD_VERSION" > version.txt
+          echo "VERSION $BUILD_VERSION"
+
+      - name: Create Git Tag for Build
+        run: |
+          git config user.name "ci"
+          git config user.email "dev@sh-edraft.de"
+          echo "tag $(cat version.txt)"
+          git tag $(cat version.txt)
+          git push origin --tags
+
+      - name: Upload build version artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: version
+          path: version.txt

.gitea/workflows/test_before_merge.yaml

@@ -0,0 +1,45 @@
+name: Test before pr merge
+run-name: Test before pr merge
+on:
+  pull_request:
+    types:
+      - opened
+      - edited
+      - reopened
+      - synchronize
+      - ready_for_review
+
+jobs:
+  test-lint:
+    runs-on: [ runner ]
+    container: git.sh-edraft.de/sh-edraft.de/act-runner:latest
+    steps:
+      - name: Clone Repository
+        uses: https://github.com/actions/checkout@v3
+        with:
+          token: ${{ secrets.CI_ACCESS_TOKEN }}
+
+      - name: Installing black
+        run: python3.12 -m pip install black
+
+      - name: Checking black
+        run: python3.12 -m black src --check
+
+  test:
+    runs-on: [ runner ]
+    container: git.sh-edraft.de/sh-edraft.de/act-runner:latest
+    steps:
+      - name: Clone Repository
+        uses: https://github.com/actions/checkout@v3
+        with:
+          token: ${{ secrets.CI_ACCESS_TOKEN }}
+
+      - name: Setting up Python 3.12
+        run: |
+          apt install -y python3.12-dev
+          bash ./install.sh
+          bash ./install.sh -dev
+
+      - name: Testing with pytest
+        run: |
+          python3.12 -m pytest

.gitignore

@@ -106,10 +106,15 @@ celerybeat.pid
 .venv
 env/
 venv/
+venv_*/
 ENV/
 env.bak/
 venv.bak/
 
+# Custom Environments
+cpl-env/
+.secret
+
 # Spyder project settings
 .spyderproject
 .spyproject
@@ -129,5 +134,11 @@ dmypy.json
 .pyre/
 
 # IDE
-.vscode/
 .idea/
+PythonImportHelper-v2-Completion.json
+
+# cpl unittest stuff
+unittests/test_*_playground
+
+# cpl logs
+**/logs/*.jsonl

.pip.conf

@@ -0,0 +1,2 @@
+[global]
+extra-index-url = https://git.sh-edraft.de/api/packages/sh-edraft.de/pypi/simple/

LICENSE

@@ -1,4 +1,4 @@
-MIT License Copyright (c) <year> <copyright holders>
+MIT License Copyright (c) 2020 - 2023 sh-edraft.de
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,2 +1,22 @@
-# sh_common_py_lib
+## Prepare for development
 
+After cloning the repository, run the following commands to set up your development environment:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+# On Windows use `.venv\Scripts\activate`
+# On Windows with git bash use `source .venv/Scripts/activate`
+bash install.sh
+```
+
+Install cpl-cli as a development package:
+
+```bash
+pip install -e src/core
+pip install -e src/cli
+# test with:
+cpl v
+```
+
+When using Pycharm, mark all directories under `src/` as "Sources Root" and `exa` to ensure proper module resolution.

cpl.json

@@ -1,56 +0,0 @@
-{
-  "ProjectSettings": {
-    "Name": "sh_cpl",
-    "Version": {
-      "Major": "2021",
-      "Minor": "04",
-      "Micro": "02"
-    },
-    "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": [
-      "colorama==0.4.4",
-      "mysql-connector==2.2.9",
-      "psutil==5.8.0",
-      "packaging==20.9",
-      "pyfiglet==0.8.post1",
-      "pynput==1.7.3",
-      "SQLAlchemy==1.4.0",
-      "setuptools==54.1.2",
-      "tabulate==0.8.9",
-      "termcolor==1.1.0",
-      "watchdog==2.0.2",
-      "wheel==0.36.2"
-    ],
-    "PythonVersion": ">=3.8",
-    "PythonPath": {},
-    "Classifiers": []
-  },
-  "BuildSettings": {
-    "SourcePath": "src",
-    "OutputPath": "dist",
-    "Main": "cpl_cli.main",
-    "EntryPoint": "cpl",
-    "IncludePackageData": true,
-    "Included": [
-      "*/templates"
-    ],
-    "Excluded": [
-      "*/__pycache__",
-      "*/logs",
-      "*/tests"
-    ],
-    "PackageData": {
-      "cpl_cli": [
-        "*.json"
-      ]
-    }
-  }
-}

cpl.workspace.json

@@ -0,0 +1,13 @@
+{
+  "name": "cpl",
+  "projects": [
+    "src/cli/cpl.project.json",
+    "src/core/cpl.project.json",
+    "src/mail/cpl.project.json",
+    "test/cpl.project.json"
+  ],
+  "defaultProject": "cpl-cli",
+  "scripts": {
+    "format": "black src"
+  }
+}

docs/cli.txt

@@ -1,19 +0,0 @@
-prefix: cpl
-commands:
-    build
-
-    generate:
-        abc             | a
-        class           | c
-        configmodel     | cm
-        enum            | e
-        service         | s
-
-    help
-    new
-        console
-
-    start
-    publish
-    update
-    version

docs/install.txt

@@ -1,2 +0,0 @@
-python setup.py install             # for install
-python setup.py sdist bdist_wheel   # for build

docs/pip.txt

@@ -1,11 +0,0 @@
-upload:
-    prod:
-        twine upload --repository-url https://pip.sh-edraft.de dist/publish/setup/*
-        twine upload -r pip.sh-edraft.de dist/publish/setup/*
-
-    dev:
-        twine upload --repository-url https://pip-dev.sh-edraft.de dist/publish/setup/*
-        twine upload -r pip-dev.sh-edraft.de dist/publish/setup/*
-
-install:
-    pip install --extra-index-url https://pip.sh-edraft.de/ sh_cpl

example/api/src/appsettings.development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "Path": "logs/",
+    "Filename": "log_$start_time.log",
+    "ConsoleLevel": "TRACE",
+    "Level": "TRACE"
+  }
+}

example/api/src/appsettings.edrafts-pc.json

@@ -0,0 +1,26 @@
+{
+  "TimeFormat": {
+    "DateFormat": "%Y-%m-%d",
+    "TimeFormat": "%H:%M:%S",
+    "DateTimeFormat": "%Y-%m-%d %H:%M:%S.%f",
+    "DateTimeLogFormat": "%Y-%m-%d_%H-%M-%S"
+  },
+
+  "Log": {
+    "Path": "logs/",
+    "Filename": "log_$start_time.log",
+    "ConsoleLevel": "TRACE",
+    "Level": "TRACE"
+  },
+
+  "Database": {
+    "Host": "localhost",
+    "User": "cpl",
+    "Port": 3306,
+    "Password": "cpl",
+    "Database": "cpl",
+    "Charset": "utf8mb4",
+    "UseUnicode": "true",
+    "Buffered": "true"
+  }
+}

example/api/src/appsettings.json

@@ -1,15 +1,15 @@
 {
-  "TimeFormatSettings": {
+  "TimeFormat": {
     "DateFormat": "%Y-%m-%d",
     "TimeFormat": "%H:%M:%S",
     "DateTimeFormat": "%Y-%m-%d %H:%M:%S.%f",
     "DateTimeLogFormat": "%Y-%m-%d_%H-%M-%S"
   },
 
-  "LoggingSettings": {
+  "Log": {
     "Path": "logs/",
     "Filename": "log_$start_time.log",
-    "ConsoleLogLevel": "ERROR",
-    "FileLogLevel": "WARN"
+    "ConsoleLevel": "ERROR",
+    "Level": "WARNING"
   }
 }

example/api/src/main.py

@@ -0,0 +1,147 @@
+from starlette.responses import JSONResponse
+
+from cpl.dependency.event_bus import EventBusABC
+from cpl.graphql.event_bus.memory import InMemoryEventBus
+from queries.cities import CityGraphType, CityFilter, CitySort
+from queries.hello import UserGraphType  # , UserFilter, UserSort, UserGraphType
+from queries.user import UserFilter, UserSort
+from cpl.api.api_module import ApiModule
+from cpl.application.application_builder import ApplicationBuilder
+from cpl.auth.schema import User, 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 cpl.graphql.application.graphql_app import GraphQLApp
+from cpl.graphql.auth.graphql_auth_module import GraphQLAuthModule
+from cpl.graphql.graphql_module import GraphQLModule
+from model.author_dao import AuthorDao
+from model.author_query import AuthorGraphType, AuthorFilter, AuthorSort
+from model.post_dao import PostDao
+from model.post_query import PostFilter, PostSort, PostGraphType, PostMutation, PostSubscription
+from permissions import PostPermissions
+from queries.hello import HelloQuery
+from scoped_service import ScopedService
+from service import PingService
+from test_data_seeder import TestDataSeeder
+
+
+def main():
+    builder = ApplicationBuilder[GraphQLApp](GraphQLApp)
+
+    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()
+        .add_transient(PingService)
+        .add_module(MySQLModule)
+        .add_module(ApiModule)
+        .add_module(GraphQLModule)
+        .add_module(GraphQLAuthModule)
+        .add_scoped(ScopedService)
+        .add_singleton(EventBusABC, InMemoryEventBus)
+        .add_cache(User)
+        .add_cache(Role)
+        .add_transient(CityGraphType)
+        .add_transient(CityFilter)
+        .add_transient(CitySort)
+        .add_transient(UserGraphType)
+        .add_transient(UserFilter)
+        .add_transient(UserSort)
+        # .add_transient(UserGraphType)
+        # .add_transient(UserFilter)
+        # .add_transient(UserSort)
+        .add_transient(HelloQuery)
+        # test data
+        .add_singleton(TestDataSeeder)
+        # authors
+        .add_transient(AuthorDao)
+        .add_transient(AuthorGraphType)
+        .add_transient(AuthorFilter)
+        .add_transient(AuthorSort)
+        # posts
+        .add_transient(PostDao)
+        .add_transient(PostGraphType)
+        .add_transient(PostFilter)
+        .add_transient(PostSort)
+        .add_transient(PostMutation)
+        .add_transient(PostSubscription)
+    )
+
+    app = builder.build()
+    app.with_logging()
+    app.with_migrations("./scripts")
+
+    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")
+
+    schema = app.with_graphql()
+    schema.query.string_field("ping", resolver=lambda: "pong")
+    schema.query.with_query("hello", HelloQuery)
+    schema.query.dao_collection_field(AuthorGraphType, AuthorDao, "authors", AuthorFilter, AuthorSort)
+    (
+        schema.query.dao_collection_field(PostGraphType, PostDao, "posts", PostFilter, PostSort)
+        # .with_require_any_permission(PostPermissions.read)
+        .with_public()
+    )
+
+    schema.mutation.with_mutation("post", PostMutation).with_public()
+
+    schema.subscription.with_subscription(PostSubscription)
+
+    app.with_auth_root_queries(True)
+    app.with_auth_root_mutations(True)
+
+    app.with_playground()
+    app.with_graphiql()
+
+    app.with_permissions(PostPermissions)
+
+    provider = builder.service_provider
+    user_cache = provider.get_service(Cache[User])
+    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/model/author.py

@@ -0,0 +1,30 @@
+from datetime import datetime
+from typing import Self
+
+from cpl.core.typing import SerialId
+from cpl.database.abc import DbModelABC
+
+
+class Author(DbModelABC[Self]):
+
+    def __init__(
+        self,
+        id: int,
+        first_name: str,
+        last_name: str,
+        deleted: bool = False,
+        editor_id: SerialId | None = None,
+        created: datetime | None = None,
+        updated: datetime | None = None,
+    ):
+        DbModelABC.__init__(self, id, deleted, editor_id, created, updated)
+        self._first_name = first_name
+        self._last_name = last_name
+
+    @property
+    def first_name(self) -> str:
+        return self._first_name
+
+    @property
+    def last_name(self) -> str:
+        return self._last_name

example/api/src/model/author_dao.py

@@ -0,0 +1,11 @@
+from cpl.database.abc import DbModelDaoABC
+from model.author import Author
+
+
+class AuthorDao(DbModelDaoABC):
+
+    def __init__(self):
+        DbModelDaoABC.__init__(self, Author, "authors")
+
+        self.attribute(Author.first_name, str, db_name="firstname")
+        self.attribute(Author.last_name, str, db_name="lastname")

example/api/src/model/author_query.py

@@ -0,0 +1,37 @@
+from cpl.graphql.schema.db_model_graph_type import DbModelGraphType
+from cpl.graphql.schema.filter.db_model_filter import DbModelFilter
+from cpl.graphql.schema.sort.sort import Sort
+from cpl.graphql.schema.sort.sort_order import SortOrder
+from model.author import Author
+
+class AuthorFilter(DbModelFilter[Author]):
+    def __init__(self):
+        DbModelFilter.__init__(self, public=True)
+        self.int_field("id")
+        self.string_field("firstName")
+        self.string_field("lastName")
+
+class AuthorSort(Sort[Author]):
+    def __init__(self):
+        Sort.__init__(self)
+        self.field("id", SortOrder)
+        self.field("firstName", SortOrder)
+        self.field("lastName", SortOrder)
+
+class AuthorGraphType(DbModelGraphType[Author]):
+
+    def __init__(self):
+        DbModelGraphType.__init__(self, public=True)
+
+        self.int_field(
+            "id",
+            resolver=lambda root: root.id,
+        ).with_public(True)
+        self.string_field(
+            "firstName",
+            resolver=lambda root: root.first_name,
+        ).with_public(True)
+        self.string_field(
+            "lastName",
+            resolver=lambda root: root.last_name,
+        ).with_public(True)

example/api/src/model/post.py

@@ -0,0 +1,44 @@
+from datetime import datetime
+from typing import Self
+
+from cpl.core.typing import SerialId
+from cpl.database.abc import DbModelABC
+
+
+class Post(DbModelABC[Self]):
+
+    def __init__(
+        self,
+        id: int,
+        author_id: SerialId,
+        title: str,
+        content: str,
+        deleted: bool = False,
+        editor_id: SerialId | None = None,
+        created: datetime | None = None,
+        updated: datetime | None = None,
+    ):
+        DbModelABC.__init__(self, id, deleted, editor_id, created, updated)
+        self._author_id = author_id
+        self._title = title
+        self._content = content
+
+    @property
+    def author_id(self) -> SerialId:
+        return self._author_id
+
+    @property
+    def title(self) -> str:
+        return self._title
+
+    @title.setter
+    def title(self, value: str):
+        self._title = value
+
+    @property
+    def content(self) -> str:
+        return self._content
+
+    @content.setter
+    def content(self, value: str):
+        self._content = value

example/api/src/model/post_dao.py

@@ -0,0 +1,15 @@
+from cpl.database.abc import DbModelDaoABC
+from model.author_dao import AuthorDao
+from model.post import Post
+
+
+class PostDao(DbModelDaoABC[Post]):
+
+    def __init__(self, authors: AuthorDao):
+        DbModelDaoABC.__init__(self, Post, "posts")
+
+        self.attribute(Post.author_id, int, db_name="authorId")
+        self.reference("author", "id", Post.author_id, "authors", authors)
+
+        self.attribute(Post.title, str)
+        self.attribute(Post.content, str)

example/api/src/model/post_query.py

@@ -0,0 +1,148 @@
+from cpl.dependency.event_bus import EventBusABC
+from cpl.graphql.query_context import QueryContext
+from cpl.graphql.schema.db_model_graph_type import DbModelGraphType
+from cpl.graphql.schema.filter.db_model_filter import DbModelFilter
+from cpl.graphql.schema.input import Input
+from cpl.graphql.schema.mutation import Mutation
+from cpl.graphql.schema.sort.sort import Sort
+from cpl.graphql.schema.sort.sort_order import SortOrder
+from cpl.graphql.schema.subscription import Subscription
+from model.author_dao import AuthorDao
+from model.author_query import AuthorGraphType, AuthorFilter
+from model.post import Post
+from model.post_dao import PostDao
+
+
+class PostFilter(DbModelFilter[Post]):
+    def __init__(self):
+        DbModelFilter.__init__(self, public=True)
+        self.int_field("id")
+        self.filter_field("author", AuthorFilter)
+        self.string_field("title")
+        self.string_field("content")
+
+
+class PostSort(Sort[Post]):
+    def __init__(self):
+        Sort.__init__(self)
+        self.field("id", SortOrder)
+        self.field("title", SortOrder)
+        self.field("content", SortOrder)
+
+
+class PostGraphType(DbModelGraphType[Post]):
+
+    def __init__(self, authors: AuthorDao):
+        DbModelGraphType.__init__(self, public=True)
+
+        self.int_field(
+            "id",
+            resolver=lambda root: root.id,
+        ).with_optional().with_public(True)
+
+        async def _a(root: Post):
+            return await authors.get_by_id(root.author_id)
+
+        def r_name(ctx: QueryContext):
+            return ctx.user.username == "admin"
+
+        self.object_field("author", AuthorGraphType, resolver=_a).with_public(True)  # .with_require_any([], [r_name]))
+        self.string_field(
+            "title",
+            resolver=lambda root: root.title,
+        ).with_public(True)
+        self.string_field(
+            "content",
+            resolver=lambda root: root.content,
+        ).with_public(True)
+
+
+class PostCreateInput(Input[Post]):
+    title: str
+    content: str
+    author_id: int
+
+    def __init__(self):
+        Input.__init__(self)
+        self.string_field("title").with_required()
+        self.string_field("content").with_required()
+        self.int_field("author_id").with_required()
+
+
+class PostUpdateInput(Input[Post]):
+    title: str
+    content: str
+    author_id: int
+
+    def __init__(self):
+        Input.__init__(self)
+        self.int_field("id").with_required()
+        self.string_field("title").with_required(False)
+        self.string_field("content").with_required(False)
+
+
+class PostSubscription(Subscription):
+    def __init__(self, bus: EventBusABC):
+        Subscription.__init__(self)
+        self._bus = bus
+
+        def selector(event: Post, info) -> bool:
+            return event.id == 101
+
+        self.subscription_field("postChange", PostGraphType, selector).with_public()
+
+
+class PostMutation(Mutation):
+
+    def __init__(self, posts: PostDao, authors: AuthorDao, bus: EventBusABC):
+        Mutation.__init__(self)
+
+        self._posts = posts
+        self._authors = authors
+        self._bus = bus
+
+        self.field("create", int, resolver=self.create_post).with_public().with_required().with_argument(
+            "input",
+            PostCreateInput,
+        ).with_required()
+        self.field("update", bool, resolver=self.update_post).with_public().with_required().with_argument(
+            "input",
+            PostUpdateInput,
+        ).with_required()
+        self.field("delete", bool, resolver=self.delete_post).with_public().with_required().with_argument(
+            "id",
+            int,
+        ).with_required()
+        self.field("restore", bool, resolver=self.restore_post).with_public().with_required().with_argument(
+            "id",
+            int,
+        ).with_required()
+
+    async def create_post(self, input: PostCreateInput) -> int:
+        return await self._posts.create(Post(0, input.author_id, input.title, input.content))
+
+    async def update_post(self, input: PostUpdateInput) -> bool:
+        post = await self._posts.get_by_id(input.id)
+        if post is None:
+            return False
+
+        post.title = input.title if input.title is not None else post.title
+        post.content = input.content if input.content is not None else post.content
+
+        await self._posts.update(post)
+        await self._bus.publish("postChange", post)
+        return True
+
+    async def delete_post(self, id: int) -> bool:
+        post = await self._posts.get_by_id(id)
+        if post is None:
+            return False
+        await self._posts.delete(post)
+        return True
+
+    async def restore_post(self, id: int) -> bool:
+        post = await self._posts.get_by_id(id)
+        if post is None:
+            return False
+        await self._posts.restore(post)
+        return True

example/api/src/permissions.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class PostPermissions(Enum):
+
+    read = "post.read"
+    write = "post.write"
+    delete = "post.delete"

example/api/src/queries/cities.py

@@ -0,0 +1,39 @@
+from cpl.graphql.schema.filter.filter import Filter
+from cpl.graphql.schema.graph_type import GraphType
+
+from cpl.graphql.schema.sort.sort import Sort
+from cpl.graphql.schema.sort.sort_order import SortOrder
+
+
+class City:
+    def __init__(self, id: int, name: str):
+        self.id = id
+        self.name = name
+
+
+class CityFilter(Filter[City]):
+    def __init__(self):
+        Filter.__init__(self)
+        self.field("id", int)
+        self.field("name", str)
+
+
+class CitySort(Sort[City]):
+    def __init__(self):
+        Sort.__init__(self)
+        self.field("id", SortOrder)
+        self.field("name", SortOrder)
+
+
+class CityGraphType(GraphType[City]):
+    def __init__(self):
+        GraphType.__init__(self)
+
+        self.int_field(
+            "id",
+            resolver=lambda root: root.id,
+        )
+        self.string_field(
+            "name",
+            resolver=lambda root: root.name,
+        )

example/api/src/queries/hello.py

@@ -0,0 +1,70 @@
+from queries.cities import CityFilter, CitySort, CityGraphType, City
+from queries.user import User, UserFilter, UserSort, UserGraphType
+from cpl.api.middleware.request import get_request
+from cpl.auth.schema import UserDao, User
+from cpl.graphql.schema.filter.filter import Filter
+from cpl.graphql.schema.graph_type import GraphType
+from cpl.graphql.schema.query import Query
+from cpl.graphql.schema.sort.sort import Sort
+from cpl.graphql.schema.sort.sort_order import SortOrder
+
+users = [User(i, f"User {i}") for i in range(1, 101)]
+cities = [City(i, f"City {i}") for i in range(1, 101)]
+
+# class UserFilter(Filter[User]):
+#     def __init__(self):
+#         Filter.__init__(self)
+#         self.field("id", int)
+#         self.field("username", str)
+#
+#
+# class UserSort(Sort[User]):
+#     def __init__(self):
+#         Sort.__init__(self)
+#         self.field("id", SortOrder)
+#         self.field("username", SortOrder)
+#
+# class UserGraphType(GraphType[User]):
+#
+#     def __init__(self):
+#         GraphType.__init__(self)
+#
+#         self.int_field(
+#             "id",
+#             resolver=lambda root: root.id,
+#         )
+#         self.string_field(
+#             "username",
+#             resolver=lambda root: root.username,
+#         )
+
+
+class HelloQuery(Query):
+    def __init__(self):
+        Query.__init__(self)
+        self.string_field(
+            "message",
+            resolver=lambda name: f"Hello {name} {get_request().state.request_id}",
+        ).with_argument("name", str, "Name to greet", "world")
+
+        self.collection_field(
+            UserGraphType,
+            "users",
+            UserFilter,
+            UserSort,
+            resolver=lambda: users,
+        )
+        self.collection_field(
+            CityGraphType,
+            "cities",
+            CityFilter,
+            CitySort,
+            resolver=lambda: cities,
+        )
+        # self.dao_collection_field(
+        #     UserGraphType,
+        #     UserDao,
+        #     "Users",
+        #     UserFilter,
+        #     UserSort,
+        # )

example/api/src/queries/user.py

@@ -0,0 +1,39 @@
+from cpl.graphql.schema.filter.filter import Filter
+from cpl.graphql.schema.graph_type import GraphType
+from cpl.graphql.schema.sort.sort import Sort
+from cpl.graphql.schema.sort.sort_order import SortOrder
+
+
+class User:
+    def __init__(self, id: int, name: str):
+        self.id = id
+        self.name = name
+
+
+class UserFilter(Filter[User]):
+    def __init__(self):
+        Filter.__init__(self)
+        self.field("id", int)
+        self.field("name", str)
+
+
+class UserSort(Sort[User]):
+    def __init__(self):
+        Sort.__init__(self)
+        self.field("id", SortOrder)
+        self.field("name", SortOrder)
+
+
+class UserGraphType(GraphType[User]):
+
+    def __init__(self):
+        GraphType.__init__(self)
+
+        self.int_field(
+            "id",
+            resolver=lambda root: root.id,
+        )
+        self.string_field(
+            "name",
+            resolver=lambda root: root.name,
+        )

example/api/src/routes/ping.py

@@ -0,0 +1,21 @@
+from urllib.request import Request
+
+from service import PingService
+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):
+    logger.info(f"Ping: {ping}")
+
+    Console.write_line(scoped.name)
+    return JSONResponse(ping.ping(r))

example/api/src/scoped_service.py

@@ -0,0 +1,14 @@
+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/api/src/scripts/0-posts.sql

@@ -0,0 +1,22 @@
+CREATE TABLE IF NOT EXISTS `authors` (
+    `id` INT(30) NOT NULL AUTO_INCREMENT,
+    `firstname` VARCHAR(64) NOT NULL,
+    `lastname` VARCHAR(64) NOT NULL,
+    deleted BOOLEAN NOT NULL DEFAULT FALSE,
+    editorId INT NULL,
+    created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    PRIMARY KEY(`id`)
+    );
+
+CREATE TABLE IF NOT EXISTS `posts` (
+    `id` INT(30) NOT NULL AUTO_INCREMENT,
+    `authorId` INT(30) NOT NULL REFERENCES `authors`(`id`) ON DELETE CASCADE,
+    `title` TEXT NOT NULL,
+    `content` TEXT NOT NULL,
+    deleted BOOLEAN NOT NULL DEFAULT FALSE,
+    editorId INT NULL,
+    created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    PRIMARY KEY(`id`)
+);

example/api/src/service.py

@@ -0,0 +1,4 @@
+class PingService:
+
+    def ping(self, r):
+        return "pong"

example/api/src/test_data_seeder.py

@@ -0,0 +1,48 @@
+from faker import Faker
+
+from cpl.database.abc import DataSeederABC
+from cpl.query import Enumerable
+from model.author import Author
+from model.author_dao import AuthorDao
+from model.post import Post
+from model.post_dao import PostDao
+
+
+fake = Faker()
+
+
+class TestDataSeeder(DataSeederABC):
+
+    def __init__(self, authors: AuthorDao, posts: PostDao):
+        DataSeederABC.__init__(self)
+
+        self._authors = authors
+        self._posts = posts
+
+    async def seed(self):
+        if await self._authors.count() == 0:
+            await self._seed_authors()
+
+        if await self._posts.count() == 0:
+            await self._seed_posts()
+
+    async def _seed_authors(self):
+        authors = Enumerable.range(0, 35).select(
+            lambda x: Author(
+                0,
+                fake.first_name(),
+                fake.last_name(),
+        )
+        ).to_list()
+        await self._authors.create_many(authors, skip_editor=True)
+
+    async def _seed_posts(self):
+        posts = Enumerable.range(0, 100).select(
+            lambda x: Post(
+                id=0,
+                author_id=fake.random_int(min=1, max=35),
+                title=fake.sentence(nb_words=6),
+                content=fake.paragraph(nb_sentences=6),
+            )
+        ).to_list()
+        await self._posts.create_many(posts, skip_editor=True)

example/console/main.py

@@ -0,0 +1,41 @@
+import time
+from cpl.core.console import Console, ForegroundColorEnum
+
+
+def test_spinner():
+    Console.write_line("test1")
+    Console.write_line("test2", 2)
+    Console.write_line("test3", 2, 3)
+    Console.write_line("test4", 2, 3, 4)
+    time.sleep(2)
+    Console.write_line("test5")
+
+
+def test_console():
+    Console.write_line("Hello World")
+    Console.write("\nName: ")
+    Console.write_line(" Hello", Console.read_line())
+    Console.write_at(5, 5, "at 5, 5")
+    Console.write_at(10, 10, "at 10, 10")
+
+
+if __name__ == "__main__":
+    Console.write_line("Hello World\n")
+    Console.clear()
+    Console.spinner(
+        "Test:", test_spinner, spinner_foreground_color=ForegroundColorEnum.cyan, text_foreground_color="green"
+    )
+    test_console()
+    Console.write_line("HOLD BACK")
+    opts = ["Option 1", "Option 2", "Option 3", "Option 4"]
+    selected = Console.select(
+        ">",
+        "Select item:",
+        opts,
+        header_foreground_color=ForegroundColorEnum.blue,
+        option_foreground_color=ForegroundColorEnum.green,
+        cursor_foreground_color=ForegroundColorEnum.red,
+    )
+    Console.write_line(f"You selected: {selected}")
+
+    Console.write_line()

example/database/src/application.py

@@ -0,0 +1,40 @@
+from cpl.application.abc import ApplicationABC
+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 model.city import City
+from model.city_dao import CityDao
+from model.user import User
+from model.user_dao import UserDao
+
+
+class Application(ApplicationABC):
+    def __init__(self, services: ServiceProvider, modules: Modules):
+        ApplicationABC.__init__(self, services, modules)
+
+        self._logger = services.get_service(LoggerABC)
+
+    async def test_daos(self):
+        userDao: UserDao = self._services.get_service(UserDao)
+        cityDao: CityDao = self._services.get_service(CityDao)
+
+        Console.write_line(await userDao.get_all())
+
+        if len(await cityDao.get_all()) == 0:
+            city_id = await cityDao.create(City(0, "Haren", "49733"))
+            await userDao.create(User(0, "NewUser", city_id))
+
+        Console.write_line(await userDao.get_all())
+
+    async def main(self):
+        self._logger.debug(f"Host: {Environment.get_host_name()}")
+        self._logger.debug(f"Environment: {Environment.get_environment()}")
+
+        await self.test_daos()
+
+        kc_admin: KeycloakAdmin = self._services.get_service(KeycloakAdmin)
+        x = kc_admin.get_users()
+        Console.write_line(x)

example/database/src/appsettings.development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "Path": "logs/",
+    "Filename": "log_$start_time.log",
+    "ConsoleLevel": "TRACE",
+    "Level": "TRACE"
+  }
+}

example/database/src/appsettings.edrafts-lapi.json

@@ -1,22 +1,22 @@
 {
-  "TimeFormatSettings": {
+  "TimeFormat": {
     "DateFormat": "%Y-%m-%d",
     "TimeFormat": "%H:%M:%S",
     "DateTimeFormat": "%Y-%m-%d %H:%M:%S.%f",
     "DateTimeLogFormat": "%Y-%m-%d_%H-%M-%S"
   },
 
-  "LoggingSettings": {
+  "Log": {
     "Path": "logs/",
     "Filename": "log_$start_time.log",
-    "ConsoleLogLevel": "TRACE",
-    "FileLogLevel": "TRACE"
+    "ConsoleLevel": "TRACE",
+    "Level": "TRACE"
   },
 
-  "DatabaseSettings": {
+  "Database": {
     "AuthPlugin": "mysql_native_password",
-    "ConnectionString": "mysql+mysqlconnector://sh_cpl:$credentials@localhost/sh_cpl",
-    "Credentials": "MHZhc0Y2bjhKc1VUMWV0Qw==",
+    "ConnectionString": "mysql+mysqlconnector://cpl:$credentials@localhost/cpl",
+    "Credentials": "Y3Bs",
     "Encoding": "utf8mb4"
   }
 }

example/database/src/appsettings.edrafts-pc.json

@@ -0,0 +1,26 @@
+{
+  "TimeFormat": {
+    "DateFormat": "%Y-%m-%d",
+    "TimeFormat": "%H:%M:%S",
+    "DateTimeFormat": "%Y-%m-%d %H:%M:%S.%f",
+    "DateTimeLogFormat": "%Y-%m-%d_%H-%M-%S"
+  },
+
+  "Log": {
+    "Path": "logs/",
+    "Filename": "log_$start_time.log",
+    "ConsoleLevel": "TRACE",
+    "Level": "TRACE"
+  },
+
+  "Database": {
+    "Host": "localhost",
+    "User": "cpl",
+    "Port": 3306,
+    "Password": "cpl",
+    "Database": "cpl",
+    "Charset": "utf8mb4",
+    "UseUnicode": "true",
+    "Buffered": "true"
+  }
+}

example/database/src/appsettings.json

@@ -1,15 +1,15 @@
 {
-  "TimeFormatSettings": {
+  "TimeFormat": {
     "DateFormat": "%Y-%m-%d",
     "TimeFormat": "%H:%M:%S",
     "DateTimeFormat": "%Y-%m-%d %H:%M:%S.%f",
     "DateTimeLogFormat": "%Y-%m-%d_%H-%M-%S"
   },
 
-  "LoggingSettings": {
+  "Log": {
     "Path": "logs/",
     "Filename": "log_$start_time.log",
-    "ConsoleLogLevel": "ERROR",
-    "FileLogLevel": "WARN"
+    "ConsoleLevel": "ERROR",
+    "Level": "WARNING"
   }
 }

example/database/src/custom_permissions.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+
+class CustomPermissions(Enum):
+    test = "test"

example/database/src/main.py

@@ -0,0 +1,19 @@
+from application import Application
+from cpl.application import ApplicationBuilder
+from custom_permissions import CustomPermissions
+from startup import Startup
+
+
+def main():
+    builder = ApplicationBuilder(Application).with_startup(Startup)
+    app = builder.build()
+
+    app.with_logging()
+    app.with_permissions(CustomPermissions)
+    app.with_migrations("./scripts")
+    app.with_seeders()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

example/database/src/main_simplified.py

@@ -0,0 +1,27 @@
+from application import Application
+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
+
+
+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()
+
+    Console.write_line(CustomPermissions.test.value in PermissionsRegistry.get())
+    app.run()
+    Console.write_line("Hello from main_simplified.py!")
+
+
+if __name__ == "__main__":
+    main()

example/database/src/model/city.py

@@ -0,0 +1,29 @@
+from datetime import datetime
+from typing import Optional
+
+from cpl.core.typing import SerialId
+from cpl.database.abc.db_model_abc import DbModelABC
+
+
+class City(DbModelABC[Self]):
+    def __init__(
+        self,
+        id: int,
+        name: str,
+        zip: str,
+        deleted: bool = False,
+        editor_id: SerialId | None = None,
+        created: datetime | None= None,
+        updated: datetime | None= None,
+    ):
+        DbModelABC.__init__(self, id, deleted, editor_id, created, updated)
+        self._name = name
+        self._zip = zip
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def zip(self) -> str:
+        return self._zip

example/database/src/model/city_dao.py

@@ -0,0 +1,11 @@
+from cpl.database.abc import DbModelDaoABC
+from model.city import City
+
+
+class CityDao(DbModelDaoABC[City]):
+
+    def __init__(self):
+        DbModelDaoABC.__init__(self, City, "city")
+
+        self.attribute(City.name, str)
+        self.attribute(City.zip, int)

example/database/src/model/user.py

@@ -0,0 +1,30 @@
+from datetime import datetime
+from typing import Optional
+
+from cpl.core.typing import SerialId
+from cpl.database.abc.db_model_abc import DbModelABC
+
+
+class User(DbModelABC[Self]):
+
+    def __init__(
+        self,
+        id: int,
+        name: str,
+        city_id: int = 0,
+        deleted: bool = False,
+        editor_id: SerialId | None = None,
+        created: datetime | None= None,
+        updated: datetime | None= None,
+    ):
+        DbModelABC.__init__(self, id, deleted, editor_id, created, updated)
+        self._name = name
+        self._city_id = city_id
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def city_id(self) -> int:
+        return self._city_id

example/database/src/model/user_dao.py

@@ -0,0 +1,13 @@
+from cpl.database.abc import DbModelDaoABC
+from model.user import User
+
+
+class UserDao(DbModelDaoABC[User]):
+
+    def __init__(self):
+        DbModelDaoABC.__init__(self, User, "users")
+
+        self.attribute(User.name, str)
+        self.attribute(User.city_id, int, db_name="CityId")
+
+        self.reference("city", "id", User.city_id, "city")

example/database/src/scripts/0-initial.sql

@@ -0,0 +1,22 @@
+CREATE TABLE IF NOT EXISTS `city` (
+    `id` INT(30) NOT NULL AUTO_INCREMENT,
+    `name` VARCHAR(64) NOT NULL,
+    `zip` VARCHAR(5) NOT NULL,
+    deleted BOOLEAN NOT NULL DEFAULT FALSE,
+    editorId INT NULL,
+    created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    PRIMARY KEY(`id`)
+);
+
+CREATE TABLE IF NOT EXISTS `users` (
+    `id` INT(30) NOT NULL AUTO_INCREMENT,
+    `name` VARCHAR(64) NOT NULL,
+    `cityId` INT(30),
+    deleted BOOLEAN NOT NULL DEFAULT FALSE,
+    editorId INT NULL,
+    created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    FOREIGN KEY (`cityId`) REFERENCES city(`id`),
+    PRIMARY KEY(`id`)
+);

example/database/src/startup.py

@@ -0,0 +1,35 @@
+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.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
+
+
+class Startup(StartupABC):
+
+    @staticmethod
+    async def configure_configuration():
+        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)
+
+    @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_transient(DataAccessObjectABC, UserDao)
+        services.add_transient(DataAccessObjectABC, CityDao)
+
+        services.add_singleton(LoggerABC, Logger)

example/di/appsettings.json

@@ -0,0 +1,15 @@
+{
+  "TimeFormat": {
+    "DateFormat": "%Y-%m-%d",
+    "TimeFormat": "%H:%M:%S",
+    "DateTimeFormat": "%Y-%m-%d %H:%M:%S.%f",
+    "DateTimeLogFormat": "%Y-%m-%d_%H-%M-%S"
+  },
+
+  "Logging": {
+    "Path": "logs/",
+    "Filename": "log_$start_time.log",
+    "ConsoleLevel": "ERROR",
+    "Level": "WARN"
+  }
+}

example/di/src/application.py

@@ -0,0 +1,45 @@
+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/di.json

@@ -1,6 +1,6 @@
 {
-  "ProjectSettings": {
-    "Name": "simple-console",
+  "Project": {
+    "Name": "di",
     "Version": {
       "Major": "0",
       "Minor": "0",
@@ -16,19 +16,21 @@
     "LicenseName": "",
     "LicenseDescription": "",
     "Dependencies": [
-      "sh_cpl==2021.4.2"
+      "cpl-core==2022.12.0"
+    ],
+    "DevDependencies": [
+      "cpl-cli==2022.12.0"
     ],
     "PythonVersion": ">=3.9.2",
-    "PythonPath": {
-      "linux": ""
-    },
+    "PythonPath": {},
     "Classifiers": []
   },
-  "BuildSettings": {
-    "SourcePath": "src",
-    "OutputPath": "dist",
-    "Main": "main",
-    "EntryPoint": "simple-console",
+  "Build": {
+    "ProjectType": "console",
+    "SourcePath": "",
+    "OutputPath": "../../dist",
+    "Main": "di.main",
+    "EntryPoint": "di",
     "IncludePackageData": false,
     "Included": [],
     "Excluded": [
@@ -36,6 +38,7 @@
       "*/logs",
       "*/tests"
     ],
-    "PackageData": {}
+    "PackageData": {},
+    "ProjectReferences": []
   }
 }

example/di/src/di_tester_service.py

@@ -0,0 +1,15 @@
+from cpl.core.console.console import Console
+from 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/di/src/main.py

@@ -6,9 +6,9 @@ from startup import Startup
 
 def main():
     app_builder = ApplicationBuilder(Application)
-    app_builder.use_startup(Startup)
+    app_builder.with_startup(Startup)
     app_builder.build().run()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

example/di/src/startup.py

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

@@ -0,0 +1,10 @@
+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/test1_service.py

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

example/di/src/test2_service.py

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

example/di/src/test_abc.py

@@ -0,0 +1,9 @@
+from abc import ABC
+
+
+class TestABC(ABC):
+    def __init__(self, name: str):
+        self._name = name
+
+    def __repr__(self):
+        return f"<{type(self).__name__} {self._name}>"

example/di/src/test_service.py

@@ -0,0 +1,14 @@
+from cpl.core.console.console import Console
+from cpl.core.utils.string import String
+
+
+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/di/src/tester.py

@@ -0,0 +1,7 @@
+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/.cpl/schematic_custom.py

@@ -0,0 +1,20 @@
+from cpl_cli.abc.generate_schematic_abc import GenerateSchematicABC
+
+
+class Custom(GenerateSchematicABC):
+    def __init__(self, *args: str):
+        GenerateSchematicABC.__init__(self, *args)
+
+    def get_code(self) -> str:
+        code = """\
+        class $Name:
+
+            def __init__(self):
+                print('hello')
+        """
+        x = self.build_code_str(code, Name=self._class_name)
+        return x
+
+    @classmethod
+    def register(cls):
+        GenerateSchematicABC.register(cls, "custom", ["cm", "CM"])

example/general/src/application.py

@@ -0,0 +1,77 @@
+import asyncio
+import time
+
+from cpl.application.abc import ApplicationABC
+from cpl.core.configuration import Configuration
+from cpl.core.console import Console
+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.dependency.typing import Modules
+from cpl.mail import EMail, EMailClientABC
+from cpl.query import List
+from scoped_service import ScopedService
+from test_service import TestService
+from test_settings import TestSettings
+
+
+class Application(ApplicationABC):
+
+    def __init__(self, services: ServiceProvider, modules: Modules):
+        ApplicationABC.__init__(self, services, modules)
+        self._logger = self._services.get_service(LoggerABC)
+        self._mailer = self._services.get_service(EMailClientABC)
+
+    def test_send_mail(self):
+        mail = EMail()
+        mail.add_header("Mime-Version: 1.0")
+        mail.add_header("Content-Type: text/plain; charset=utf-8")
+        mail.add_header("Content-Transfer-Encoding: quoted-printable")
+        mail.add_receiver("sven.heidemann@sh-edraft.de")
+        mail.subject = f"Test - {Environment.get_host_name()}"
+        mail.body = "Dies ist ein Test :D"
+        self._mailer.send_mail(mail)
+
+    @staticmethod
+    def _wait(time_ms: int):
+        time.sleep(time_ms)
+
+    async 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.spinner("Test", self._wait, 2, spinner_foreground_color="red")
+        test: TestService = self._services.get_service(TestService)
+        ip_pipe: IPAddressPipe = self._services.get_service(IPAddressPipe)
+        test.run()
+        test2: TestService = self._services.get_service(TestService)
+        ip_pipe2: IPAddressPipe = self._services.get_service(IPAddressPipe)
+        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")
+
+        test_settings = Configuration.get(TestSettings)
+        Console.write_line(test_settings.value)
+        Console.write_line("reload config")
+        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)
+        test_settings1 = Configuration.get(TestSettings)
+        Console.write_line(test_settings1.value)
+        # self.test_send_mail()

example/general/src/appsettings.development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "Path": "logs/",
+    "Filename": "log_$start_time.log",
+    "ConsoleLevel": "TRACE",
+    "Level": "TRACE"
+  }
+}

example/general/src/appsettings.edrafts-lapi.json

@@ -1,29 +1,20 @@
 {
-  "TimeFormatSettings": {
+  "TimeFormat": {
     "DateFormat": "%Y-%m-%d",
     "TimeFormat": "%H:%M:%S",
     "DateTimeFormat": "%Y-%m-%d %H:%M:%S.%f",
     "DateTimeLogFormat": "%Y-%m-%d_%H-%M-%S"
   },
-
-  "LoggingSettings": {
+  "Logging": {
     "Path": "logs/",
     "Filename": "log_$start_time.log",
-    "ConsoleLogLevel": "TRACE",
-    "FileLogLevel": "TRACE"
+    "ConsoleLevel": "TRACE",
+    "Level": "TRACE"
   },
-
-  "EMailClientSettings": {
+  "EMailClient": {
     "Host": "mail.sh-edraft.de",
     "Port": "587",
     "UserName": "dev-srv@sh-edraft.de",
     "Credentials": "RmBOQX1eNFYiYjgsSid3fV1nelc2WA=="
-  },
-
-  "DatabaseSettings": {
-    "AuthPlugin": "mysql_native_password",
-    "ConnectionString": "mysql+mysqlconnector://sh_cpl:$credentials@localhost/sh_cpl",
-    "Credentials": "MHZhc0Y2bjhKc1VUMWV0Qw==",
-    "Encoding": "utf8mb4"
   }
 }

example/general/src/appsettings.edrafts-pc.json

@@ -0,0 +1,37 @@
+{
+  "TimeFormat": {
+    "DateFormat": "%Y-%m-%d",
+    "TimeFormat": "%H:%M:%S",
+    "DateTimeFormat": "%Y-%m-%d %H:%M:%S.%f",
+    "DateTimeLogFormat": "%Y-%m-%d_%H-%M-%S"
+  },
+
+  "Logging": {
+    "Path": "logs/",
+    "Filename": "log_$start_time.log",
+    "ConsoleLevel": "TRACE",
+    "Level": "TRACE"
+  },
+
+  "EMailClient": {
+    "Host": "mail.sh-edraft.de",
+    "Port": "587",
+    "UserName": "dev-srv@sh-edraft.de",
+    "Credentials": "RmBOQX1eNFYiYjgsSid3fV1nelc2WA=="
+  },
+
+  "Database": {
+    "Host": "localhost",
+    "User": "sh_cpl",
+    "Password": "MHZhc0Y2bjhKc1VUMWV0Qw==",
+    "Database": "sh_cpl",
+    "Charset": "utf8mb4",
+    "UseUnicode": "true",
+    "Buffered": "true",
+    "AuthPlugin": "mysql_native_password"
+  },
+
+  "Test": {
+    "Value": 20
+  }
+}

example/general/src/appsettings.json

@@ -0,0 +1,15 @@
+{
+  "TimeFormat": {
+    "DateFormat": "%Y-%m-%d",
+    "TimeFormat": "%H:%M:%S",
+    "DateTimeFormat": "%Y-%m-%d %H:%M:%S.%f",
+    "DateTimeLogFormat": "%Y-%m-%d_%H-%M-%S"
+  },
+
+  "Logging": {
+    "Path": "logs/",
+    "Filename": "log_$start_time.log",
+    "ConsoleLevel": "ERROR",
+    "Level": "WARN"
+  }
+}

example/general/src/db/__init__.py

@@ -0,0 +1 @@
+

example/general/src/hosted_service.py

@@ -0,0 +1,30 @@
+import asyncio
+from datetime import datetime
+
+from cpl.core.console import Console
+from cpl.core.time.cron import Cron
+from cpl.core.service.cronjob import CronjobABC
+from cpl.core.service.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
+
+
+class MyCronJob(CronjobABC):
+    def __init__(self):
+        CronjobABC.__init__(self, Cron("*/1 * * * *"))  # Every minute
+
+    async def loop(self):
+        Console.write_line(f"[{datetime.now()}] Hello from Cronjob!")

example/general/src/main.py

@@ -0,0 +1,19 @@
+from application import Application
+from cpl.application import ApplicationBuilder
+from cpl.core.console import Console
+from test_extension import TestExtension
+from startup import Startup
+from test_startup_extension import TestStartupExtension
+
+
+def main():
+    Console.write_line("\n\n--- Application Starting ---\n")
+    app_builder = ApplicationBuilder(Application)
+    app_builder.with_startup(Startup)
+    app_builder.with_extension(TestStartupExtension)
+    app_builder.with_extension(TestExtension)
+    app_builder.build().run()
+
+
+if __name__ == "__main__":
+    main()

example/general/src/scoped_service.py

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

example/general/src/startup.py

@@ -0,0 +1,28 @@
+from cpl.application.abc import StartupABC
+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, MyCronJob
+from scoped_service import ScopedService
+from test_service import TestService
+
+
+class Startup(StartupABC):
+
+    @staticmethod
+    def configure_configuration():
+        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)
+
+    @staticmethod
+    def configure_services(services: ServiceCollection):
+        services.add_logging()
+        services.add_module(MailModule)
+        services.add_transient(IPAddressPipe)
+        services.add_singleton(TestService)
+        services.add_scoped(ScopedService)
+        services.add_hosted_service(Hosted)
+        services.add_hosted_service(MyCronJob)

example/general/src/test_extension.py

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

example/general/src/test_service.py

@@ -0,0 +1,13 @@
+from cpl.core.console.console import Console
+from cpl.dependency import ServiceProvider
+from cpl.core.pipes.ip_address_pipe import IPAddressPipe
+
+
+class TestService:
+    def __init__(self, provider: ServiceProvider):
+        self._provider = provider
+
+    def run(self):
+        Console.write_line("Hello World!", self._provider)
+        ip = [192, 168, 178, 30]
+        Console.write_line(ip, IPAddressPipe.to_str(ip))

example/general/src/test_settings.py

@@ -0,0 +1,6 @@
+from cpl.core.configuration import ConfigurationModelABC
+
+
+class TestSettings(ConfigurationModelABC):
+    def __init__(self, value: int = None):
+        self.value = value

example/general/src/test_startup_extension.py

@@ -0,0 +1,14 @@
+from cpl.application.abc import StartupExtensionABC
+from cpl.core.console import Console
+from cpl.dependency import ServiceCollection
+
+
+class TestStartupExtension(StartupExtensionABC):
+
+    @staticmethod
+    def configure_configuration():
+        Console.write_line("config")
+
+    @staticmethod
+    def configure_services(services: ServiceCollection):
+        Console.write_line("services")

example/query/main.py

@@ -0,0 +1,60 @@
+from cpl.core.console import Console
+from cpl.core.utils.benchmark import Benchmark
+from cpl.query.enumerable import Enumerable
+from cpl.query.immutable_list import ImmutableList
+from cpl.query.list import List
+from cpl.query.set import Set
+
+
+def _default():
+    Console.write_line(Enumerable.empty().to_list())
+
+    Console.write_line(Enumerable.range(0, 100).length)
+    Console.write_line(Enumerable.range(0, 100).to_list())
+
+    Console.write_line(Enumerable.range(0, 100).where(lambda x: x % 2 == 0).length)
+    Console.write_line(
+        Enumerable.range(0, 100).where(lambda x: x % 2 == 0).to_list().select(lambda x: str(x)).to_list()
+    )
+    Console.write_line(List)
+
+    s =Enumerable.range(0, 10).to_set()
+    Console.write_line(s)
+    s.add(1)
+    Console.write_line(s)
+
+    data = Enumerable(
+        [
+            {"name": "Alice", "age": 30},
+            {"name": "Dave", "age": 35},
+            {"name": "Charlie", "age": 25},
+            {"name": "Bob", "age": 25},
+        ]
+    )
+
+    Console.write_line(data.order_by(lambda x: x["age"]).to_list())
+    Console.write_line(data.order_by(lambda x: x["age"]).then_by(lambda x: x["name"]).to_list())
+    Console.write_line(data.order_by(lambda x: x["name"]).then_by(lambda x: x["age"]).to_list())
+
+
+def t_benchmark(data: list):
+    Benchmark.all("Enumerable", lambda: Enumerable(data).where(lambda x: x % 2 == 0).select(lambda x: x * 2).to_list())
+    Benchmark.all("Set", lambda: Set(data).where(lambda x: x % 2 == 0).select(lambda x: x * 2).to_list())
+    Benchmark.all("List", lambda: List(data).where(lambda x: x % 2 == 0).select(lambda x: x * 2).to_list())
+    Benchmark.all(
+        "ImmutableList", lambda: ImmutableList(data).where(lambda x: x % 2 == 0).select(lambda x: x * 2).to_list()
+    )
+    Benchmark.all("List comprehension", lambda: [x * 2 for x in data if x % 2 == 0])
+
+
+def main():
+    N = 1_000_000
+    data = list(range(N))
+    t_benchmark(data)
+
+    Console.write_line()
+    _default()
+
+
+if __name__ == "__main__":
+    main()

example/translation/cpl-workspace.json

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

example/translation/src/application.py

@@ -0,0 +1,27 @@
+from cpl.application import ApplicationABC
+from cpl.core.configuration import ConfigurationABC
+from cpl.core.console import Console
+from cpl.dependency import ServiceProvider
+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):
+        ApplicationABC.__init__(self, config, services)
+
+        self._translate: TranslatePipe = services.get_service(TranslatePipe)
+        self._translation: TranslationServiceABC = services.get_service(TranslationServiceABC)
+        self._translation_settings: TranslationSettings = config.get_configuration(TranslationSettings)
+
+        self._translation.load_by_settings(config.get_configuration(TranslationSettings))
+        self._translation.set_default_lang("de")
+
+    def configure(self): ...
+
+    def main(self):
+        Console.write_line(self._translate.transform("main.text.hello_world"))
+        self._translation.set_lang("en")
+        Console.write_line(self._translate.transform("main.text.hello_world"))
+        Console.write_line(self._translate.transform("main.text.hello"))

example/translation/src/appsettings.json

@@ -0,0 +1,23 @@
+{
+  "TimeFormat": {
+    "DateFormat": "%Y-%m-%d",
+    "TimeFormat": "%H:%M:%S",
+    "DateTimeFormat": "%Y-%m-%d %H:%M:%S.%f",
+    "DateTimeLogFormat": "%Y-%m-%d_%H-%M-%S"
+  },
+
+  "Logging": {
+    "Path": "logs/",
+    "Filename": "log_$start_time.log",
+    "ConsoleLevel": "ERROR",
+    "Level": "WARN"
+  },
+
+  "Translation": {
+    "Languages":[
+      "de",
+      "en"
+    ],
+    "DefaultLanguage": "en"
+  }
+}

example/translation/src/main.py

@@ -1,14 +1,14 @@
 from cpl.application import ApplicationBuilder
 
-from application import Application
-from startup import Startup
+from translation.application import Application
+from translation.startup import Startup
 
 
 def main():
     app_builder = ApplicationBuilder(Application)
-    app_builder.use_startup(Startup)
+    app_builder.with_startup(Startup)
     app_builder.build().run()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

example/translation/src/startup.py

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

example/translation/src/translation.json

@@ -1,6 +1,6 @@
 {
-  "ProjectSettings": {
-    "Name": "simple-app",
+  "Project": {
+    "Name": "translation",
     "Version": {
       "Major": "0",
       "Minor": "0",
@@ -16,19 +16,21 @@
     "LicenseName": "",
     "LicenseDescription": "",
     "Dependencies": [
-      "sh_cpl==2021.4.2"
+      "cpl-core>=2022.6.0"
     ],
-    "PythonVersion": ">=3.9.2",
-    "PythonPath": {
-      "linux": ""
-    },
+    "DevDependencies": [
+      "cpl-cli>=2022.6.0"
+    ],
+    "PythonVersion": ">=3.10.4",
+    "PythonPath": {},
     "Classifiers": []
   },
-  "BuildSettings": {
-    "SourcePath": "src",
-    "OutputPath": "dist",
-    "Main": "main",
-    "EntryPoint": "simple-app",
+  "Build": {
+    "ProjectType": "console",
+    "SourcePath": "",
+    "OutputPath": "../../dist",
+    "Main": "translation.main",
+    "EntryPoint": "translation",
     "IncludePackageData": false,
     "Included": [],
     "Excluded": [
@@ -36,6 +38,7 @@
       "*/logs",
       "*/tests"
     ],
-    "PackageData": {}
+    "PackageData": {},
+    "ProjectReferences": []
   }
 }

example/translation/src/translation/de.json

@@ -0,0 +1,7 @@
+{
+  "main": {
+    "text": {
+      "hello_world": "Hallo Welt"
+    }
+  }
+}

example/translation/src/translation/en.json

@@ -0,0 +1,7 @@
+{
+  "main": {
+    "text": {
+      "hello_world": "Hello World"
+    }
+  }
+}

install.sh

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Optionaler Dev-Installationsmodus
+dev_mode=false
+if [[ "${1:-}" == "-dev" ]]; then
+  dev_mode=true
+fi
+
+shopt -s nullglob
+
+# Wähle die passende Requirements-Datei
+pattern='requirements.txt'
+msg_hint='src/*/requirements.txt'
+if $dev_mode; then
+  pattern='requirements.dev.txt'
+  msg_hint='src/*/requirements.dev.txt'
+fi
+
+req_files=(src/*/"$pattern")
+if ((${#req_files[@]} == 0)); then
+  echo "Keine Requirements-Dateien gefunden unter '$msg_hint'" >&2
+  exit 1
+fi
+
+tmp_combined="$(mktemp)"
+trap 'rm -f "$tmp_combined"' EXIT
+
+# Kombiniere, filtere Kommentare/Whitespace, entferne cpl-*, dedupliziere.
+awk '
+  function trim(s){ sub(/^[[:space:]]+/,"",s); sub(/[[:space:]]+$/,"",s); return s }
+
+  {
+    line=$0
+    if (line ~ /^[[:space:]]*#/) next
+    sub(/#[^!].*$/,"",line)
+    line=trim(line)
+    if (line == "") next
+
+    e = line
+    sub(/^-e[[:space:]]+/,"",e)
+    token = e
+    sub(/\[.*/,"",token)
+    n = split(token, a, /[<>=!~;@[:space:]]/)
+    name = tolower(a[1])
+
+    if (name ~ /^cpl-/) next
+    print line
+  }
+' "${req_files[@]}" | sort -u > "$tmp_combined"
+
+if ! [ -s "$tmp_combined" ]; then
+  echo "Nichts zu installieren nach dem Entfernen von cpl-* Paketen." >&2
+  exit 0
+fi
+
+echo "Installiere Abhängigkeiten (ohne cpl-*) aus:"
+printf '  - %s\n' "${req_files[@]}"
+echo
+echo "Finale Menge zur Installation:"
+cat "$tmp_combined"
+echo
+
+python -m pip install -r "$tmp_combined"

pyproject.toml

@@ -0,0 +1,18 @@
+[tool.black]
+line-length = 120
+
+[tool.pytest.ini_options]
+pythonpath = [
+    "src/api",
+    "src/application",
+    "src/auth",
+    "src/cli",
+    "src/core",
+    "src/database",
+    "src/dependency",
+    "src/graphql",
+    "src/mail",
+    "src/query",
+    "src/translation"
+]
+testpaths = ["test"]