ScriptCollection 3.5.118__py3-none-any.whl → 3.5.120__py3-none-any.whl

ScriptCollection/CertificateUpdater.py

@@ -24,7 +24,7 @@ class CertificateUpdater:
 
     def __init__(self, domains: list[str], email: str, current_file: str, arguments: list[str]):
         self.__sc = ScriptCollectionCore()
-        self.maximal_age_of_certificates_in_days = 60
+        self.maximal_age_of_certificates_in_days = 15
         self.__domains = domains
         self.__email = email
         self.__current_folder = current_file
@@ -126,7 +126,7 @@ class CertificateUpdater:
     def __get_last_certificate_update_date(self) -> datetime:
         if os.path.exists(self.__last_update_timestamp_file):
             filecontent = GeneralUtilities.read_text_from_file(self.__last_update_timestamp_file)
-            return GeneralUtilities.string_to_datetime(filecontent.replace("\r", "").replace("\n", ""))
+            return GeneralUtilities.string_to_datetime(filecontent.replace("\r", GeneralUtilities.empty_string).replace("\n", GeneralUtilities.empty_string))
         else:
             return datetime(year=1970, month=1, day=1)
 
@@ -142,5 +142,8 @@ class CertificateUpdater:
         args = parser.parse_args(self.__arguments)
         now = datetime.now()
         if (self.__get_last_certificate_update_date()+timedelta(days=self.maximal_age_of_certificates_in_days)) < now or args.force:
+            GeneralUtilities.write_message_to_stdout(f"Update certificates...")
             self.__update_certificates()
             self.__set_last_certificate_update_date(now)
+        else:
+            GeneralUtilities.write_message_to_stdout(f"Certificates are already up to date.")

ScriptCollection/GeneralUtilities.py

@@ -38,6 +38,8 @@ class GeneralUtilities:
     __datetime_format: str = "%Y-%m-%dT%H:%M:%S"
     __date_format: str = "%Y-%m-%d"
 
+    empty_string: str = ""
+
     @staticmethod
     def get_modest_dark_url() -> str:
         return "https://aniondev.github.io/CDN/ScriptCollectionDesigns/ModestDark/Style.css"
@@ -46,6 +48,10 @@ class GeneralUtilities:
     def is_generic(t: typing.Type):
         return hasattr(t, "__origin__")
 
+    @staticmethod
+    def is_debugger_attached():
+        return sys.gettrace() is not None
+
     @staticmethod
     def check_arguments(function):
         def __check_function(*args, **named_args):
@@ -234,6 +240,32 @@ class GeneralUtilities:
         text = GeneralUtilities.replace_underscores_in_text(text, replacements)
         GeneralUtilities.write_text_to_file(file, text, encoding)
 
+    @staticmethod
+    def print_text(text: str, print_to_stdout: bool = True):
+        GeneralUtilities.__print_text_to_console(text, print_to_stdout)
+
+    @staticmethod
+    def print_text_in_green(text: str, print_to_stdout: bool = True):
+        GeneralUtilities.__print_text_to_console(f"\033[32m{text}\033[0m", print_to_stdout)
+
+    @staticmethod
+    def print_text_in_yellow(text: str, print_to_stdout: bool = True):
+        GeneralUtilities.__print_text_to_console(f"\033[33m{text}\033[0m", print_to_stdout)
+
+    @staticmethod
+    def print_text_in_red(text: str, print_to_stdout: bool = True):
+        GeneralUtilities.__print_text_to_console(f"\033[31m{text}\033[0m", print_to_stdout)
+
+    @staticmethod
+    def print_text_in_cyan(text: str, print_to_stdout: bool = True):
+        GeneralUtilities.__print_text_to_console(f"\033[36m{text}\033[0m", print_to_stdout)
+
+    @staticmethod
+    def __print_text_to_console(text: str, print_to_stdout: bool = True):
+        output = sys.stdout if print_to_stdout else sys.stderr
+        output.write(text)
+        output.flush()
+
     @staticmethod
     @check_arguments
     def reconfigure_standrd_input_and_outputs():
@@ -243,16 +275,29 @@ class GeneralUtilities:
 
     @staticmethod
     @check_arguments
-    def write_message_to_stdout(message: str):
-        for line in GeneralUtilities.string_to_lines(message):
-            sys.stdout.write(GeneralUtilities.str_none_safe(line)+"\n")
+    def write_message_to_stdout_advanced(message: str, add_empty_lines: bool = True, adapt_lines: bool = True, append_linebreak: bool = True):
+        new_line_character: str = "\n" if append_linebreak else ""
+        for line in GeneralUtilities.string_to_lines(message, add_empty_lines, adapt_lines):
+            sys.stdout.write(GeneralUtilities.str_none_safe(line)+new_line_character)
             sys.stdout.flush()
 
+    @staticmethod
+    @check_arguments
+    def write_message_to_stdout(message: str):
+        GeneralUtilities.write_message_to_stdout_advanced(message, True, True, True)
+
+    @staticmethod
+    @check_arguments
+    def write_message_to_stderr_advanced(message: str, add_empty_lines: bool = True, adapt_lines: bool = True, append_linebreak: bool = True):
+        new_line_character: str = "\n" if append_linebreak else ""
+        for line in GeneralUtilities.string_to_lines(message, add_empty_lines, adapt_lines):
+            sys.stderr.write(GeneralUtilities.str_none_safe(line)+new_line_character)
+            sys.stderr.flush()
+
     @staticmethod
     @check_arguments
     def write_message_to_stderr(message: str):
-        sys.stderr.write(GeneralUtilities.str_none_safe(message)+"\n")
-        sys.stderr.flush()
+        GeneralUtilities.write_message_to_stderr_advanced(message, True, True, True)
 
     @staticmethod
     @check_arguments
@@ -260,7 +305,7 @@ class GeneralUtilities:
         if GeneralUtilities.string_has_content(os_error.filename2):
             secondpath = f" {os_error.filename2}"
         else:
-            secondpath = ""
+            secondpath = GeneralUtilities.empty_string
         return f"Related path(s): {os_error.filename}{secondpath}"
 
     @staticmethod
@@ -315,7 +360,7 @@ class GeneralUtilities:
             return True
         type_of_argument = type(argument)
         if type_of_argument == str:
-            return argument == ""
+            return argument == GeneralUtilities.empty_string
         else:
             raise ValueError(f"expected string-variable in argument of string_is_none_or_empty but the type was '{str(type_of_argument)}'")
 
@@ -325,7 +370,7 @@ class GeneralUtilities:
         if GeneralUtilities.string_is_none_or_empty(string):
             return True
         else:
-            return string.strip() == ""
+            return string.strip() == GeneralUtilities.empty_string
 
     @staticmethod
     @check_arguments
@@ -378,7 +423,7 @@ class GeneralUtilities:
         if GeneralUtilities.file_ends_with_content(file):
             return "\n"
         else:
-            return ""
+            return GeneralUtilities.empty_string
 
     @staticmethod
     @check_arguments
@@ -861,7 +906,7 @@ class GeneralUtilities:
         result = list()
         if list_as_string is not None:
             list_as_string = list_as_string.strip()
-            if list_as_string == "":
+            if list_as_string == GeneralUtilities.empty_string:
                 pass
             elif separator in list_as_string:
                 for item in list_as_string.split(separator):
@@ -922,7 +967,7 @@ class GeneralUtilities:
         if positive:
             return "✅"
         else:
-            return ""
+            return GeneralUtilities.empty_string
 
     @staticmethod
     @check_arguments

ScriptCollection/ImageUpdater.py

@@ -0,0 +1,477 @@
+from abc import abstractmethod
+from enum import Enum
+import json
+import re
+from urllib.parse import quote
+import yaml
+import requests
+from packaging import version as ve
+from packaging.version import Version
+from .GeneralUtilities import GeneralUtilities
+
+
+class VersionEcholon(Enum):
+    Patch = 0
+    LatestPatchOrLatestMinor = 1
+    LatestPatchOrLatestMinorOrNextMajor = 2
+    Newest = 3
+
+
+class ImageUpdaterHelper:
+
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def _internal_filter_for_major_and_minor_versions(versions: list[Version], major: int, minor: int) -> Version:
+        return [v for v in versions if v.major == major and v.minor == minor]
+
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def _internal_filter_for_major_versions(versions: list[Version], major: int) -> Version:
+        return [v for v in versions if v.major == major]
+
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def _internal_get_latest_patch_version(newer_versions: list[Version], current_version: Version) -> Version:
+        candidates = ImageUpdaterHelper._internal_filter_for_major_and_minor_versions(newer_versions, current_version.major, current_version.minor)
+        if len(candidates) == 0:
+            return current_version
+        result = ImageUpdaterHelper.get_latest_version(candidates)
+        return result
+
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def _internal_get_latest_patch_or_latest_minor_version(newer_versions: list[Version], current_version: Version) -> Version:
+        candidates = ImageUpdaterHelper._internal_filter_for_major_versions(newer_versions, current_version.major)
+        if len(candidates) == 0:
+            return current_version
+        result = ImageUpdaterHelper.get_latest_version(candidates)
+        return result
+
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def _internal_get_latest_patch_or_latest_minor_or_next_major_version(newer_versions: list[Version], current_version: Version) -> Version:
+        candidates = ImageUpdaterHelper._internal_filter_for_major_versions(newer_versions, current_version.major+1)
+        if 0 < len(candidates):
+            result = ImageUpdaterHelper.get_latest_version(candidates)
+            return result
+        else:
+            candidates = ImageUpdaterHelper._internal_filter_for_major_versions(newer_versions, current_version.major)
+            if len(candidates) == 0:
+                return current_version
+            result = ImageUpdaterHelper.get_latest_version(candidates)
+            return result
+
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def filter_considering_echolog(newer_versions: list[Version], current_version: Version, version_echolon: VersionEcholon) -> Version:
+        if version_echolon == VersionEcholon.Patch:
+            return ImageUpdaterHelper._internal_get_latest_patch_version(newer_versions, current_version)
+        elif version_echolon == VersionEcholon.LatestPatchOrLatestMinor:
+            return ImageUpdaterHelper._internal_get_latest_patch_or_latest_minor_version(newer_versions, current_version)
+        elif version_echolon == VersionEcholon.LatestPatchOrLatestMinorOrNextMajor:
+            return ImageUpdaterHelper._internal_get_latest_patch_or_latest_minor_or_next_major_version(newer_versions, current_version)
+        elif version_echolon == VersionEcholon.Newest:
+            return ImageUpdaterHelper.get_latest_version(newer_versions)
+        else:
+            raise ValueError(f"Unknown version-echolon")
+
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def get_latest_version(versions: list[Version]) -> Version:
+        result = max(versions)
+        return result
+
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def get_latest_version_from_versiontrings(version_strings: list[str]) -> str:
+        parsed = [ve.parse(v) for v in version_strings]
+        result = max(parsed)
+        return str(result)
+
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def filter_for_newer_versions(comparison_version: Version, versions_to_filter: list[Version]) -> list[Version]:
+        result = [v for v in versions_to_filter if comparison_version < v]
+        return result
+
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def get_versions_in_docker_hub(image: str, search_string: str, filter_regex: str, maximal_amount_of_items_to_load: int = 250) -> list[Version]:
+        if "/" not in image:
+            image = f"library/{image}"
+        response = requests.get(f"https://hub.docker.com/v2/repositories/{quote(image)}/tags?name={quote(search_string)}&ordering=last_updated&page=1&page_size={str(maximal_amount_of_items_to_load)}", timeout=20, headers={'Cache-Control': 'no-cache'})
+        if response.status_code != 200:
+            raise ValueError(f"Failed to fetch data from Docker Hub: {response.status_code}")
+        response_text = response.text
+        data = json.loads(response_text)
+        tags: list[str] = [tag["name"] for tag in data["results"] if re.match(filter_regex, tag["name"])]
+        versions = [tag.split("-")[0] for tag in tags]
+        result = [ve.parse(v) for v in versions]
+        return result
+
+
+class ConcreteImageUpdater:
+
+    @abstractmethod
+    @GeneralUtilities.check_arguments
+    def version_to_tag(self,  version: Version) -> str:
+        raise NotImplementedError
+
+    @abstractmethod
+    @GeneralUtilities.check_arguments
+    def get_latest_version_of_image(self,  image: str, version_echolon: VersionEcholon, current_version: Version) -> Version:
+        raise NotImplementedError
+
+    @abstractmethod
+    @GeneralUtilities.check_arguments
+    def get_supported_images(self) -> list[str]:
+        raise NotImplementedError
+
+    @abstractmethod
+    @GeneralUtilities.check_arguments
+    def get_version_from_tag(self, image: str, tag: str) -> Version:
+        raise NotImplementedError
+
+
+class ConcreteImageUpdaterForNginx(ConcreteImageUpdater):
+
+    @GeneralUtilities.check_arguments
+    def version_to_tag(self,  version: Version) -> str:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_latest_version_of_image(self,  image: str, version_echolon: VersionEcholon, current_version: Version) -> Version:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_supported_images(self) -> list[str]:
+        return ["nginx"]
+
+    @GeneralUtilities.check_arguments
+    def get_version_from_tag(self, image: str, tag: str) -> Version:
+        raise NotImplementedError
+
+
+class ConcreteImageUpdaterForGitLab(ConcreteImageUpdater):
+
+    @GeneralUtilities.check_arguments
+    def version_to_tag(self,  version: Version) -> str:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_latest_version_of_image(self,  image: str, version_echolon: VersionEcholon, current_version: Version) -> Version:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_supported_images(self) -> list[str]:
+        return ["gitlab/gitlab-ce", "gitlab/gitlab-ee"]
+
+    @GeneralUtilities.check_arguments
+    def get_version_from_tag(self, image: str, tag: str) -> Version:
+        raise NotImplementedError
+
+
+class ConcreteImageUpdaterForRegistry(ConcreteImageUpdater):
+
+    @GeneralUtilities.check_arguments
+    def version_to_tag(self,  version: Version) -> str:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_latest_version_of_image(self,  image: str, version_echolon: VersionEcholon, current_version: Version) -> Version:
+        raise NotImplementedError
+
+    @abstractmethod
+    @GeneralUtilities.check_arguments
+    def get_supported_images(self) -> list[str]:
+        return []  # TODO
+
+    @GeneralUtilities.check_arguments
+    def get_version_from_tag(self, image: str, tag: str) -> Version:
+        raise NotImplementedError
+
+
+class ConcreteImageUpdaterForPrometheus(ConcreteImageUpdater):
+
+    @GeneralUtilities.check_arguments
+    def version_to_tag(self,  version: Version) -> str:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_latest_version_of_image(self,  image: str, version_echolon: VersionEcholon, current_version: Version) -> Version:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_supported_images(self) -> list[str]:
+        return []  # TODO
+
+    @GeneralUtilities.check_arguments
+    def get_version_from_tag(self, image: str, tag: str) -> Version:
+        raise NotImplementedError
+
+
+class ConcreteImageUpdaterForPrometheusBlackboxExporter(ConcreteImageUpdater):
+
+    @GeneralUtilities.check_arguments
+    def version_to_tag(self,  version: Version) -> str:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_latest_version_of_image(self,  image: str, version_echolon: VersionEcholon, current_version: Version) -> Version:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_supported_images(self) -> list[str]:
+        return []  # TODO
+
+    @GeneralUtilities.check_arguments
+    def get_version_from_tag(self, image: str, tag: str) -> Version:
+        raise NotImplementedError
+
+
+class ConcreteImageUpdaterForPrometheusNginxExporter(ConcreteImageUpdater):
+
+    @GeneralUtilities.check_arguments
+    def version_to_tag(self,  version: Version) -> str:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_latest_version_of_image(self,  image: str, version_echolon: VersionEcholon, current_version: Version) -> Version:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_supported_images(self) -> list[str]:
+        return []  # TODO
+
+    @GeneralUtilities.check_arguments
+    def get_version_from_tag(self, image: str, tag: str) -> Version:
+        raise NotImplementedError
+
+
+class ConcreteImageUpdaterForPrometheusNodeExporter(ConcreteImageUpdater):
+
+    @GeneralUtilities.check_arguments
+    def version_to_tag(self,  version: Version) -> str:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_latest_version_of_image(self,  image: str, version_echolon: VersionEcholon, current_version: Version) -> Version:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_supported_images(self) -> list[str]:
+        return []  # TODO
+
+    @GeneralUtilities.check_arguments
+    def get_version_from_tag(self, image: str, tag: str) -> Version:
+        raise NotImplementedError
+
+
+class ConcreteImageUpdaterForKeycloak(ConcreteImageUpdater):
+
+    @GeneralUtilities.check_arguments
+    def version_to_tag(self,  version: Version) -> str:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_latest_version_of_image(self,  image: str, version_echolon: VersionEcholon, current_version: Version) -> Version:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_supported_images(self) -> list[str]:
+        return []  # TODO
+
+    @GeneralUtilities.check_arguments
+    def get_version_from_tag(self, image: str, tag: str) -> Version:
+        raise NotImplementedError
+
+
+class ConcreteImageUpdaterForMariaDB(ConcreteImageUpdater):
+
+    @GeneralUtilities.check_arguments
+    def version_to_tag(self,  version: Version) -> str:
+        return f"{version.major}.{version.minor}.{version.micro}"
+
+    @GeneralUtilities.check_arguments
+    def get_latest_version_of_image(self,  image: str, version_echolon: VersionEcholon, current_version: Version) -> Version:
+        versions = ImageUpdaterHelper.get_versions_in_docker_hub(image, ".", "^\\d+\\.\\d+\\.\\d+$", 999)
+        newer_versions = ImageUpdaterHelper.filter_for_newer_versions(current_version, versions)
+        result = ImageUpdaterHelper.filter_considering_echolog(newer_versions, current_version, version_echolon)
+        return result
+
+    @GeneralUtilities.check_arguments
+    def get_supported_images(self) -> list[str]:
+        return ["mariadb"]
+
+    @GeneralUtilities.check_arguments
+    def get_version_from_tag(self, image: str, tag: str) -> Version:
+        return ve.parse(tag)
+
+
+class ConcreteImageUpdaterForPostgreSQL(ConcreteImageUpdater):
+
+    @GeneralUtilities.check_arguments
+    def version_to_tag(self,  version: Version) -> str:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_latest_version_of_image(self,  image: str, version_echolon: VersionEcholon, current_version: Version) -> Version:
+        raise NotImplementedError
+
+    @GeneralUtilities.check_arguments
+    def get_supported_images(self) -> list[str]:
+        return []  # TODO
+
+    @GeneralUtilities.check_arguments
+    def get_version_from_tag(self, image: str, tag: str) -> Version:
+        raise NotImplementedError
+
+
+class ConcreteImageUpdaterForAdminer(ConcreteImageUpdater):
+
+    @GeneralUtilities.check_arguments
+    def version_to_tag(self,  version: Version) -> str:
+        return f"{version.major}.{version.minor}.{version.micro}"
+
+    @GeneralUtilities.check_arguments
+    def get_latest_version_of_image(self,  image: str, version_echolon: VersionEcholon, current_version: Version) -> Version:
+        versions = ImageUpdaterHelper.get_versions_in_docker_hub(image, ".", "^\\d+\\.\\d+\\.\\d+$", 999)
+        newer_versions = ImageUpdaterHelper.filter_for_newer_versions(current_version, versions)
+        result = ImageUpdaterHelper.filter_considering_echolog(newer_versions, current_version, version_echolon)
+        return result
+
+    @GeneralUtilities.check_arguments
+    def get_supported_images(self) -> list[str]:
+        return ["adminer"]
+
+    @GeneralUtilities.check_arguments
+    def get_version_from_tag(self, image: str, tag: str) -> Version:
+        return ve.parse(tag)
+
+
+class ImageUpdater:
+
+    updater: list[ConcreteImageUpdater] = None
+
+    def __init__(self):
+        self.updater = list[ConcreteImageUpdater]()
+
+    def add_default_mapper(self) -> None:
+        self.updater.append(ConcreteImageUpdaterForNginx())
+        self.updater.append(ConcreteImageUpdaterForGitLab())
+        self.updater.append(ConcreteImageUpdaterForRegistry())
+        self.updater.append(ConcreteImageUpdaterForPrometheus())
+        self.updater.append(ConcreteImageUpdaterForPrometheusBlackboxExporter())
+        self.updater.append(ConcreteImageUpdaterForPrometheusNginxExporter())
+        self.updater.append(ConcreteImageUpdaterForPrometheusNodeExporter())
+        self.updater.append(ConcreteImageUpdaterForKeycloak())
+        self.updater.append(ConcreteImageUpdaterForMariaDB())
+        self.updater.append(ConcreteImageUpdaterForPostgreSQL())
+        self.updater.append(ConcreteImageUpdaterForAdminer())
+
+    @GeneralUtilities.check_arguments
+    def check_service_for_newest_version(self, dockercompose_file: str, service_name: str) -> bool:
+        imagename, existing_tag, existing_version = self.get_current_version_of_service_from_docker_compose_file(dockercompose_file, service_name)  # pylint:disable=unused-variable
+        newest_version, newest_tag = self.get_latest_version_of_image(imagename, VersionEcholon.Newest, existing_version)  # pylint:disable=unused-variable
+        if existing_version < newest_version:
+            GeneralUtilities.write_message_to_stdout(f"Service {service_name} with image {imagename} uses tag {existing_version}. The newest available version of this image is {newest_version}.")
+            return True
+        else:
+            return False
+
+    @GeneralUtilities.check_arguments
+    def check_for_newest_version(self, dockercompose_file: str, excluded_services: list[str] = []) -> bool:
+        all_services = self.get_services_from_docker_compose_file(dockercompose_file)
+        services_to_check = [service for service in all_services if service not in all_services]
+        newer_version_available: bool = False
+        for service_to_check in services_to_check:
+            if self.check_service_for_newest_version(dockercompose_file, service_to_check):
+                newer_version_available = True
+        return newer_version_available
+
+    @GeneralUtilities.check_arguments
+    def update_all_services_in_docker_compose_file(self, dockercompose_file: str, version_echolon: VersionEcholon, except_services: list[str] = []):
+        all_services = self.get_services_from_docker_compose_file(dockercompose_file)
+        services_to_update = [service for service in all_services if service not in except_services]
+        self.update_services_in_docker_compose_file(dockercompose_file, services_to_update, version_echolon)
+
+    @GeneralUtilities.check_arguments
+    def update_services_in_docker_compose_file(self, dockercompose_file: str, service_names: list[str], version_echolon: VersionEcholon):
+        for service_name in service_names:
+            if self.service_has_image_information(dockercompose_file, service_name):
+                self.update_service_in_docker_compose_file(dockercompose_file, service_name, version_echolon)
+
+    @GeneralUtilities.check_arguments
+    def service_has_image_information(self, dockercompose_file: str, service_name: str) -> bool:
+        with open(dockercompose_file, 'r', encoding="utf-8") as file:
+            compose_data = yaml.safe_load(file)
+            service = compose_data.get('services', {}).get(service_name, {})
+            image = service.get('image', None)
+            return image is not None
+
+    @GeneralUtilities.check_arguments
+    def update_service_in_docker_compose_file(self, dockercompose_file: str, service_name: str, version_echolon: VersionEcholon):
+        imagename, existing_tag, existing_version = self.get_current_version_of_service_from_docker_compose_file(dockercompose_file, service_name)  # pylint:disable=unused-variable
+        result = self.get_latest_version_of_image(imagename, version_echolon, existing_version)
+        newest_version = result[0]
+        newest_tag = result[1]
+        if existing_version < newest_version:
+
+            with open(dockercompose_file, 'r', encoding="utf-8") as f:
+                compose_data = yaml.safe_load(f)
+
+            services = compose_data.get("services", {})
+            if service_name not in services:
+                raise ValueError(f"Service '{service_name}' not found.")
+
+            image = services[service_name].get("image")
+            if not image:
+                raise ValueError(f"Service '{service_name}' does not have an image-field.")
+
+            imagename = image.split(":")[0]
+            services[service_name]["image"] = imagename+":"+newest_tag
+
+            with open(dockercompose_file, 'w', encoding="utf-8") as f:
+                yaml.dump(compose_data, f, default_flow_style=False)
+
+    @GeneralUtilities.check_arguments
+    def get_current_version_of_service_from_docker_compose_file(self, dockercompose_file: str, service_name: str) -> tuple[str, str, Version]:  # returns (image,existing_tag,existing_version)
+        with open(dockercompose_file, 'r', encoding="utf-8") as file:
+            compose_data = yaml.safe_load(file)
+            service = compose_data.get('services', {}).get(service_name, {})
+            image = str(service.get('image', None))
+            if image:
+                if ':' in image:
+                    name, tag = image.rsplit(':', 1)
+                else:
+                    name, tag = image, 'latest'
+                return name, tag, self.get_docker_version_from_tag(name, tag)
+            else:
+                raise ValueError(f"Service '{service_name}' in '{dockercompose_file}'")
+
+    @GeneralUtilities.check_arguments
+    def __get_updater_for_image(self,  image: str) -> str:
+        for updater in self.updater:
+            if image in updater.get_supported_images():
+                return updater
+        raise ValueError(f"No updater available for image '{image}'")
+
+    @GeneralUtilities.check_arguments
+    def get_docker_version_from_tag(self,  image: str, tag: str) -> Version:
+        updater: ImageUpdater = self.__get_updater_for_image(image)
+        return updater.get_version_from_tag(image, tag)
+
+    @GeneralUtilities.check_arguments
+    def get_latest_version_of_image(self,  image: str, version_echolon: VersionEcholon, current_version: Version) -> tuple[Version, str]:
+        updater: ImageUpdater = self.__get_updater_for_image(image)
+        newest_version: Version = updater.get_latest_version_of_image(image, version_echolon, current_version)
+        newest_tag: str = updater.version_to_tag(newest_version)
+        return (newest_version, newest_tag)
+
+    @GeneralUtilities.check_arguments
+    def get_services_from_docker_compose_file(self, dockercompose_file: str) -> list[str]:
+        with open(dockercompose_file, 'r', encoding="utf-8") as f:
+            compose_data = yaml.safe_load(f)
+            services = compose_data.get('services', {})
+            result = list(services.keys())
+            return result

ScriptCollection/SCLog.py

@@ -29,42 +29,55 @@ class SCLog:
         self.log(f"Exception: {message}; Exception-details: {str(ex)}; Traceback:  {current_traceback.format_exc()}", LogLevel.Error)
 
     @GeneralUtilities.check_arguments
-    def log(self, message: str, loglevel: LogLevel):
+    def log(self, message: str, loglevel: LogLevel = None):
+        for line in GeneralUtilities.string_to_lines(message, True, False):
+            self.__log_line(line, loglevel)
+
+    @GeneralUtilities.check_arguments
+    def __log_line(self, message: str, loglevel: LogLevel = None):
         if loglevel is None:
             loglevel = LogLevel.Information
 
         if int(loglevel) > int(self.loglevel):
             return
 
+        part1: str = ""
+        part2: str = ""
+        part3: str = message
+
         if loglevel == LogLevel.Warning:
-            message = f"Warning: {message}"
+            part3 = f"Warning: {message}"
         if loglevel == LogLevel.Debug:
-            message = f"Debug: {message}"
+            part3 = f"Debug: {message}"
         if self.add_overhead:
-            if loglevel == LogLevel.Error:
-                message = f"[Error] {message}"
+            part1 = f"[{GeneralUtilities.datetime_to_string_for_logfile_entry(datetime.now())}] ["
+            if loglevel == LogLevel.Information:
+                part2 = f"Information"
+            elif loglevel == LogLevel.Error:
+                part2 = f"Error"
             elif loglevel == LogLevel.Warning:
-                message = f"[Warning] {message}"
+                part2 = f"Warning"
             elif loglevel == LogLevel.Debug:
-                message = f"[Debug] {message}"
-            elif loglevel == LogLevel.Information:
-                message = f"[Information] {message}"
+                part2 = f"Debug"
             else:
                 raise ValueError("Unknown loglevel.")
+            part3 = f"] {message}"
 
-            message = f"[{GeneralUtilities.datetime_to_string_for_logfile_entry(datetime.now())}] {message}"
-
-        if loglevel == LogLevel.Error:
-            GeneralUtilities.write_message_to_stderr(message)
+        print_to_std_out: bool = loglevel in (LogLevel.Debug, LogLevel.Information)
+        GeneralUtilities.print_text(part1, print_to_std_out)
+        # if the control-characters for colors cause problems then maybe it can be checked with sys.stdout.isatty() if colors should be printed
+        if loglevel == LogLevel.Information:
+            GeneralUtilities.print_text_in_green(part2, print_to_std_out)
+        elif loglevel == LogLevel.Error:
+            GeneralUtilities.print_text_in_red(part2, print_to_std_out)
         elif loglevel == LogLevel.Warning:
-            GeneralUtilities.write_message_to_stderr(message)
+            GeneralUtilities.print_text_in_yellow(part2, print_to_std_out)
         elif loglevel == LogLevel.Debug:
-            GeneralUtilities.write_message_to_stdout(message)
-        elif loglevel == LogLevel.Information:
-            GeneralUtilities.write_message_to_stdout(message)
+            GeneralUtilities.print_text_in_cyan(part2, print_to_std_out)
         else:
             raise ValueError("Unknown loglevel.")
+        GeneralUtilities.print_text(part3+"\n", print_to_std_out)
 
         if self.log_file is not None:
             GeneralUtilities.ensure_file_exists(self.log_file)
-            GeneralUtilities.append_line_to_file(self.log_file, message)
+            GeneralUtilities.append_line_to_file(self.log_file, part1+part2+part3)

ScriptCollection/ScriptCollectionCore.py

@@ -28,12 +28,12 @@ import qrcode
 import pycdlib
 import send2trash
 from pypdf import PdfReader, PdfWriter
-from .GeneralUtilities import GeneralUtilities, VersionEcholon
+from .GeneralUtilities import GeneralUtilities
 from .ProgramRunnerBase import ProgramRunnerBase
 from .ProgramRunnerPopen import ProgramRunnerPopen
 from .ProgramRunnerEpew import ProgramRunnerEpew, CustomEpewArgument
 
-version = "3.5.118"
+version = "3.5.120"
 __version__ = version
 
 
@@ -63,7 +63,7 @@ class ScriptCollectionCore:
         errors = list()
         filename = os.path.relpath(file, working_directory)
         if treat_warnings_as_errors:
-            errorsonly_argument = ""
+            errorsonly_argument = GeneralUtilities.empty_string
         else:
             errorsonly_argument = " --errors-only"
         (exit_code, stdout, stderr, _) = self.run_program("pylint", filename + errorsonly_argument, working_directory, throw_exception_if_exitcode_is_not_zero=False)
@@ -167,14 +167,14 @@ class ScriptCollectionCore:
     @GeneralUtilities.check_arguments
     def get_parent_commit_ids_of_commit(self, repository_folder: str, commit_id: str) -> str:
         self.assert_is_git_repository(repository_folder)
-        return self.run_program("git", f'log --pretty=%P -n 1 "{commit_id}"', repository_folder, throw_exception_if_exitcode_is_not_zero=True)[1].replace("\r", "").replace("\n", "").split(" ")
+        return self.run_program("git", f'log --pretty=%P -n 1 "{commit_id}"', repository_folder, throw_exception_if_exitcode_is_not_zero=True)[1].replace("\r", GeneralUtilities.empty_string).replace("\n", GeneralUtilities.empty_string).split(" ")
 
     @GeneralUtilities.check_arguments
     def get_all_authors_and_committers_of_repository(self, repository_folder: str, subfolder: str = None, verbosity: int = 1) -> list[tuple[str, str]]:
         self.assert_is_git_repository(repository_folder)
         space_character = "_"
         if subfolder is None:
-            subfolder_argument = ""
+            subfolder_argument = GeneralUtilities.empty_string
         else:
             subfolder_argument = f" -- {subfolder}"
         log_result = self.run_program("git", f'log --pretty=%aN{space_character}%aE%n%cN{space_character}%cE HEAD{subfolder_argument}', repository_folder, verbosity=0)
@@ -194,7 +194,7 @@ class ScriptCollectionCore:
         self.assert_is_git_repository(repository_folder)
         since_as_string = self.__datetime_to_string_for_git(since)
         until_as_string = self.__datetime_to_string_for_git(until)
-        result = filter(lambda line: not GeneralUtilities.string_is_none_or_whitespace(line), self.run_program("git", f'log --since "{since_as_string}" --until "{until_as_string}" --pretty=format:"%H" --no-patch', repository_folder, throw_exception_if_exitcode_is_not_zero=True)[1].split("\n").replace("\r", ""))
+        result = filter(lambda line: not GeneralUtilities.string_is_none_or_whitespace(line), self.run_program("git", f'log --since "{since_as_string}" --until "{until_as_string}" --pretty=format:"%H" --no-patch', repository_folder, throw_exception_if_exitcode_is_not_zero=True)[1].split("\n").replace("\r", GeneralUtilities.empty_string))
         if ignore_commits_which_are_not_in_history_of_head:
             result = [commit_id for commit_id in result if self.git_commit_is_ancestor(repository_folder, commit_id)]
         return result
@@ -557,19 +557,19 @@ class ScriptCollectionCore:
     def git_get_current_branch_name(self, repository: str) -> str:
         self.assert_is_git_repository(repository)
         result = self.run_program_argsasarray("git", ["rev-parse", "--abbrev-ref", "HEAD"], repository, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
-        return result[1].replace("\r", "").replace("\n", "")
+        return result[1].replace("\r", GeneralUtilities.empty_string).replace("\n", GeneralUtilities.empty_string)
 
     @GeneralUtilities.check_arguments
     def git_get_commitid_of_tag(self, repository: str, tag: str) -> str:
         self.assert_is_git_repository(repository)
         stdout = self.run_program_argsasarray("git", ["rev-list", "-n", "1", tag], repository, verbosity=0)
-        result = stdout[1].replace("\r", "").replace("\n", "")
+        result = stdout[1].replace("\r", GeneralUtilities.empty_string).replace("\n", GeneralUtilities.empty_string)
         return result
 
     @GeneralUtilities.check_arguments
     def git_get_tags(self, repository: str) -> list[str]:
         self.assert_is_git_repository(repository)
-        tags = [line.replace("\r", "") for line in self.run_program_argsasarray(
+        tags = [line.replace("\r", GeneralUtilities.empty_string) for line in self.run_program_argsasarray(
             "git", ["tag"], repository)[1].split("\n") if len(line) > 0]
         return tags
 
@@ -604,14 +604,14 @@ class ScriptCollectionCore:
     def get_latest_git_tag(self, repository_folder: str) -> str:
         self.assert_is_git_repository(repository_folder)
         result = self.run_program_argsasarray("git", ["describe", "--tags", "--abbrev=0"], repository_folder, verbosity=0)
-        result = result[1].replace("\r", "").replace("\n", "")
+        result = result[1].replace("\r", GeneralUtilities.empty_string).replace("\n", GeneralUtilities.empty_string)
         return result
 
     @GeneralUtilities.check_arguments
     def get_staged_or_committed_git_ignored_files(self, repository_folder: str) -> list[str]:
         self.assert_is_git_repository(repository_folder)
         temp_result = self.run_program_argsasarray("git", ["ls-files", "-i", "-c", "--exclude-standard"], repository_folder, verbosity=0)
-        temp_result = temp_result[1].replace("\r", "")
+        temp_result = temp_result[1].replace("\r", GeneralUtilities.empty_string)
         result = [line for line in temp_result.split("\n") if len(line) > 0]
         return result
 
@@ -1243,7 +1243,7 @@ class ScriptCollectionCore:
     def __adjust_folder_name(self, folder: str) -> str:
         result = os.path.dirname(folder).replace("\\", "/")
         if result == "/":
-            return ""
+            return GeneralUtilities.empty_string
         else:
             return result
 
@@ -1449,7 +1449,7 @@ class ScriptCollectionCore:
         GeneralUtilities.assert_condition(not GeneralUtilities.string_is_none_or_whitespace(ls_result[1]), f"'ls -ld' of '{file_or_folder}' had an empty output. StdErr: '{ls_result[2]}'")
         GeneralUtilities.write_message_to_stdout(ls_result[1])
         output = ls_result[1]
-        result = output.replace("\n", "")
+        result = output.replace("\n", GeneralUtilities.empty_string)
         result = ' '.join(result.split())   # reduce multiple whitespaces to one
         return result
 
@@ -1538,7 +1538,7 @@ class ScriptCollectionCore:
                 try:
                     while not q_stdout.empty():
                         out_line: str = q_stdout.get_nowait()
-                        out_line = out_line.replace("\r", "").replace("\n", "")
+                        out_line = out_line.replace("\r", GeneralUtilities.empty_string).replace("\n", GeneralUtilities.empty_string)
                         if GeneralUtilities.string_has_content(out_line):
                             stdout_result.append(out_line)
                             reading_stdout_last_time_resulted_in_exception = False
@@ -1552,7 +1552,7 @@ class ScriptCollectionCore:
                 try:
                     while not q_stderr.empty():
                         err_line: str = q_stderr.get_nowait()
-                        err_line = err_line.replace("\r", "").replace("\n", "")
+                        err_line = err_line.replace("\r", GeneralUtilities.empty_string).replace("\n", GeneralUtilities.empty_string)
                         if GeneralUtilities.string_has_content(err_line):
                             stderr_result.append(err_line)
                             reading_stderr_last_time_resulted_in_exception = False
@@ -1600,8 +1600,8 @@ class ScriptCollectionCore:
                 GeneralUtilities.write_message_to_stdout(f"Run '{info_for_log}'.")
 
             exit_code: int = None
-            stdout: str = ""
-            stderr: str = ""
+            stdout: str = GeneralUtilities.empty_string
+            stderr: str = GeneralUtilities.empty_string
             pid: int = None
 
             with self.__run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, verbosity, print_errors_as_information, log_file, timeoutInSeconds, addLogOverhead, title, log_namespace, arguments_for_log, custom_argument, interactive) as process:
@@ -1971,10 +1971,10 @@ DNS                 = {domain}
         csproj_filename = os.path.basename(csproj_file)
         GeneralUtilities.write_message_to_stdout(f"Check for updates in {csproj_filename}")
         result = self.run_program_with_retry("dotnet", f"list {csproj_filename} package --outdated", folder, print_errors_as_information=True)
-        for line in result[1].replace("\r", "").split("\n"):
+        for line in result[1].replace("\r", GeneralUtilities.empty_string).split("\n"):
             # Relevant output-lines are something like "    > NJsonSchema             10.7.0        10.7.0      10.9.0"
             if ">" in line:
-                package_name = line.replace(">", "").strip().split(" ")[0]
+                package_name = line.replace(">", GeneralUtilities.empty_string).strip().split(" ")[0]
                 if not (package_name in ignored_dependencies):
                     GeneralUtilities.write_message_to_stdout(f"Update package {package_name}...")
                     self.run_program("dotnet", f"add {csproj_filename} package {package_name}", folder, print_errors_as_information=True)
@@ -2330,47 +2330,3 @@ TXDX
     @GeneralUtilities.check_arguments
     def install_requirementstxt_file(self, requirements_txt_file: str, folder: str, verbosity: int):
         self.run_program_argsasarray("pip", ["install", "-r", requirements_txt_file], folder, verbosity=verbosity)
-
-    @GeneralUtilities.check_arguments
-    def update_all_services_in_docker_compose_file(self, dockercompose_file: str, version_echolon: VersionEcholon):
-        raise ValueError("not implemented yet")
-
-    @GeneralUtilities.check_arguments
-    def update_service_in_docker_compose_file(self, dockercompose_file: str, service_name: str, version_echolon: VersionEcholon):
-        raise ValueError("not implemented yet")
-
-    @GeneralUtilities.check_arguments
-    def get_current_version_of_service_from_docker_compose_file(self, dockercompose_file: str, service_name: str):
-        raise ValueError("not implemented yet")
-
-    @GeneralUtilities.check_arguments
-    def get_services_from_docker_compose_file(self, dockercompose_file: str):
-        raise ValueError("not implemented yet")
-
-    @GeneralUtilities.check_arguments
-    def get_next_version_for_nginx(self, registry_address: str, current_version: str, version_echolon: VersionEcholon):
-        raise ValueError("not implemented yet")
-
-    @GeneralUtilities.check_arguments
-    def get_next_version_for_prometheus(self, registry_address: str, current_version: str, version_echolon: VersionEcholon):
-        raise ValueError("not implemented yet")
-
-    @GeneralUtilities.check_arguments
-    def get_next_version_for_blackbox_exporter(self, registry_address: str, current_version: str, version_echolon: VersionEcholon):
-        raise ValueError("not implemented yet")
-
-    @GeneralUtilities.check_arguments
-    def get_next_version_for_gitlab(self, registry_address: str, current_version: str, version_echolon: VersionEcholon):
-        raise ValueError("not implemented yet")
-
-    @GeneralUtilities.check_arguments
-    def get_next_version_for_nextcloud(self, registry_address: str, current_version: str, version_echolon: VersionEcholon):
-        raise ValueError("not implemented yet")
-
-    @GeneralUtilities.check_arguments
-    def get_next_version_for_genericservice(self, registry_address: str, current_version: str, version_echolon: VersionEcholon, tag_prefix: str):
-        raise ValueError("not implemented yet")
-
-    @GeneralUtilities.check_arguments
-    def get_all_available_tags(self, registry_address: str, service: str):
-        raise ValueError("not implemented yet")

ScriptCollection/TasksForCommonProjectStructure.py

@@ -340,15 +340,15 @@ class TasksForCommonProjectStructure:
         filename = os.path.basename(wheel_file)
 
         if gpg_identity is None:
-            gpg_identity_argument = ""
+            gpg_identity_argument = GeneralUtilities.empty_string
         else:
-            gpg_identity_argument = ""  # f" --sign --identity {gpg_identity}"
+            gpg_identity_argument = GeneralUtilities.empty_string  # f" --sign --identity {gpg_identity}"
             # disabled due to https://blog.pypi.org/posts/2023-05-23-removing-pgp/
 
         if verbosity > 2:
             verbose_argument = " --verbose"
         else:
-            verbose_argument = ""
+            verbose_argument = GeneralUtilities.empty_string
 
         twine_argument = f"upload{gpg_identity_argument} --repository {repository} --non-interactive {filename} --disable-progress-bar"
         twine_argument = f"{twine_argument} --username __token__ --password {api_key}{verbose_argument}"
@@ -649,8 +649,8 @@ class TasksForCommonProjectStructure:
         filename = os.path.basename(csproj_file)
         GeneralUtilities.write_message_to_stdout(f"Check {filename}...")
         file_content = GeneralUtilities.read_text_from_file(csproj_file)
-        regex = regex.replace("\r", "").replace("\n", "\\n")
-        file_content = file_content.replace("\r", "")
+        regex = regex.replace("\r", GeneralUtilities.empty_string).replace("\n", "\\n")
+        file_content = file_content.replace("\r", GeneralUtilities.empty_string)
         match = re.match(regex, file_content)
         return match is not None
 
@@ -972,13 +972,13 @@ class TasksForCommonProjectStructure:
         diff_target_file = os.path.join(diff_target_folder, "DiffReport.html")
         title = (f'Reference of codeunit {codeunitname} {codeunit_version_identifier} (contained in project <a href="{public_repository_url}">{projectname}</a> {project_version_identifier})')
         if public_repository_url is None:
-            repo_url_html = ""
+            repo_url_html = GeneralUtilities.empty_string
         else:
             repo_url_html = f'<a href="{public_repository_url}/tree/{branch}/{codeunitname}">Source-code</a>'
         if codeunit_has_testcases:
             coverage_report_link = '<a href="./TestCoverageReport/index.html">Test-coverage-report</a><br>'
         else:
-            coverage_report_link = ""
+            coverage_report_link = GeneralUtilities.empty_string
         index_file_for_reference = os.path.join(target_folder, "index.html")
 
         design_file = None
@@ -987,7 +987,7 @@ class TasksForCommonProjectStructure:
             design_file = GeneralUtilities.get_modest_dark_url()
         # TODO make designs from customizable sources be available by a customizable name and outsource this to a class-property because this is duplicated code.
         if design_file is None:
-            design_html = ""
+            design_html = GeneralUtilities.empty_string
         else:
             design_html = f'<link type="text/css" rel="stylesheet" href="{design_file}" />'
 
@@ -1095,7 +1095,7 @@ class TasksForCommonProjectStructure:
             if version_identifier_of_project == "Latest":
                 latest_version_hint = f" (v{project_version})"
             else:
-                latest_version_hint = ""
+                latest_version_hint = GeneralUtilities.empty_string
             reference_versions_html_lines.append(f'    <h2>{version_identifier_of_project}{latest_version_hint}</h2>')
             reference_versions_html_lines.append("    Contained codeunits:<br/>")
             reference_versions_html_lines.append("    <ul>")
@@ -1113,7 +1113,7 @@ class TasksForCommonProjectStructure:
             design_file = GeneralUtilities.get_modest_dark_url()
         # TODO make designs from customizable sources be available by a customizable name and outsource this to a class-property because this is duplicated code.
         if design_file is None:
-            design_html = ""
+            design_html = GeneralUtilities.empty_string
         else:
             design_html = f'<link type="text/css" rel="stylesheet" href="{design_file}" />'
 
@@ -1423,7 +1423,7 @@ class TasksForCommonProjectStructure:
         self.__sc.format_xml_file(sbom_folder+f"/{codeunitname}.{codeunitversion}.sbom.xml")
 
     @GeneralUtilities.check_arguments
-    def push_docker_build_artifact(self, push_artifacts_file: str, registry: str, verbosity: int, push_readme: bool, commandline_arguments: list[str], repository_folder_name: str) -> None:
+    def push_docker_build_artifact(self, push_artifacts_file: str, registry: str, verbosity: int, push_readme: bool, commandline_arguments: list[str], repository_folder_name: str,image_name:str=None) -> None:
         folder_of_this_file = os.path.dirname(push_artifacts_file)
         filename = os.path.basename(push_artifacts_file)
         codeunitname_regex: str = "([a-zA-Z0-9]+)"
@@ -1441,15 +1441,17 @@ class TasksForCommonProjectStructure:
         image_file = sc.find_file_by_extension(applicationimage_folder, "tar")
         image_filename = os.path.basename(image_file)
         codeunit_version = self.get_version_of_codeunit(os.path.join(codeunit_folder, f"{codeunitname}.codeunit.xml"))
-        image_tag_name = codeunitname.lower()
-        repo = f"{registry}/{image_tag_name}"
+        if image_name is None:
+            image_name = codeunitname
+        image_name=image_name.lower()
+        repo = f"{registry}/{image_name}"
         image_latest = f"{repo}:latest"
         image_version = f"{repo}:{codeunit_version}"
         GeneralUtilities.write_message_to_stdout("Load image...")
         sc.run_program("docker", f"load --input {image_filename}", applicationimage_folder, verbosity=verbosity)
         GeneralUtilities.write_message_to_stdout("Tag image...")
-        sc.run_program("docker", f"tag {image_tag_name}:{codeunit_version} {image_latest}", verbosity=verbosity)
-        sc.run_program("docker", f"tag {image_tag_name}:{codeunit_version} {image_version}", verbosity=verbosity)
+        sc.run_program("docker", f"tag {image_name}:{codeunit_version} {image_latest}", verbosity=verbosity)
+        sc.run_program("docker", f"tag {image_name}:{codeunit_version} {image_version}", verbosity=verbosity)
         GeneralUtilities.write_message_to_stdout("Push image...")
         sc.run_program("docker", f"push {image_latest}", verbosity=verbosity)
         sc.run_program("docker", f"push {image_version}", verbosity=verbosity)
@@ -1940,7 +1942,7 @@ class TasksForCommonProjectStructure:
     def set_constant(self, codeunit_folder: str, constantname: str, constant_value: str, documentationsummary: str = None, constants_valuefile: str = None) -> None:
         self.assert_is_codeunit_folder(codeunit_folder)
         if documentationsummary is None:
-            documentationsummary = ""
+            documentationsummary = GeneralUtilities.empty_string
         constants_folder = os.path.join(codeunit_folder, "Other", "Resources", "Constants")
         GeneralUtilities.ensure_directory_exists(constants_folder)
         constants_metafile = os.path.join(constants_folder, f"{constantname}.constant.xml")
@@ -2259,7 +2261,7 @@ class TasksForCommonProjectStructure:
         codeunit_file = os.path.join(codeunit_folder, f"{codeunit_name}.codeunit.xml")
         root: etree._ElementTree = etree.parse(codeunit_file)
         ignoreddependencies = root.xpath('//cps:codeunit/cps:properties/cps:updatesettings/cps:ignoreddependencies/cps:ignoreddependency', namespaces=namespaces)
-        result = [x.text.replace("\\n", "").replace("\\r", "").replace("\n", "").replace("\r", "").strip() for x in ignoreddependencies]
+        result = [x.text.replace("\\n", GeneralUtilities.empty_string).replace("\\r", GeneralUtilities.empty_string).replace("\n", GeneralUtilities.empty_string).replace("\r", GeneralUtilities.empty_string).strip() for x in ignoreddependencies]
         if print_warnings_for_ignored_dependencies and len(result) > 0:
             GeneralUtilities.write_message_to_stderr(f"Warning: Codeunit {codeunit_name} contains the following dependencies which will are ignoed for automatic updates: "+', '.join(result))
         return result
@@ -2346,7 +2348,7 @@ class TasksForCommonProjectStructure:
         sc: ScriptCollectionCore = ScriptCollectionCore()
         workspace_file: str = sc.find_file_by_extension(repository_folder, "code-workspace")
         task_file: str = os.path.join(repository_folder, "Taskfile.yml")
-        lines: list[str] = ["version: '3'", "", "tasks:", ""]
+        lines: list[str] = ["version: '3'", GeneralUtilities.empty_string, "tasks:", GeneralUtilities.empty_string]
         workspace_file_content: str = GeneralUtilities.read_text_from_file(workspace_file)
         jsoncontent = json.loads(workspace_file_content)
         tasks = jsoncontent["tasks"]["tasks"]
@@ -2389,7 +2391,7 @@ class TasksForCommonProjectStructure:
                     aliases = task["aliases"]
                     for alias in aliases:
                         lines.append(f'      - {alias}')
-                lines.append("")
+                lines.append(GeneralUtilities.empty_string)
         GeneralUtilities.write_lines_to_file(task_file, lines)
 
     @GeneralUtilities.check_arguments
@@ -2860,21 +2862,21 @@ class TasksForCommonProjectStructure:
 
             description = self.get_codeunit_description(codeunit_file)
 
-            lines.append(f"")
+            lines.append(GeneralUtilities.empty_string)
             lines.append(f"[{codeunitname}]")
             lines.append(f"note as {codeunitname}Note")
             lines.append(f"  {description}")
             lines.append(f"end note")
             lines.append(f"{codeunitname} .. {codeunitname}Note")
 
-        lines.append(f"")
+        lines.append(GeneralUtilities.empty_string)
         for codeunitname in codeunits:
             codeunit_file: str = os.path.join(repository_folder, codeunitname, f"{codeunitname}.codeunit.xml")
             dependent_codeunits = self.get_dependent_code_units(codeunit_file)
             for dependent_codeunit in dependent_codeunits:
                 lines.append(f"{codeunitname} --> {dependent_codeunit}")
 
-        lines.append(f"")
+        lines.append(GeneralUtilities.empty_string)
         lines.append("@enduml")
 
         GeneralUtilities.write_lines_to_file(target_file, lines)
@@ -3015,15 +3017,15 @@ class TasksForCommonProjectStructure:
         build_folder = os.path.join(other_folder, "Build")
         quality_folder = os.path.join(other_folder, "QualityCheck")
         reference_folder = os.path.join(other_folder, "Reference")
-        additional_arguments_c: str = ""
-        additional_arguments_b: str = ""
-        additional_arguments_r: str = ""
-        additional_arguments_l: str = ""
-        additional_arguments_g: str = ""
-        additional_arguments_f: str = ""
+        additional_arguments_c: str = GeneralUtilities.empty_string
+        additional_arguments_b: str = GeneralUtilities.empty_string
+        additional_arguments_r: str = GeneralUtilities.empty_string
+        additional_arguments_l: str = GeneralUtilities.empty_string
+        additional_arguments_g: str = GeneralUtilities.empty_string
+        additional_arguments_f: str = GeneralUtilities.empty_string
         general_argument = f' --overwrite_verbosity {str(verbosity)} --overwrite_targetenvironmenttype {target_environmenttype}'
 
-        c_additionalargumentsfile_argument = ""
+        c_additionalargumentsfile_argument = GeneralUtilities.empty_string
 
         if is_pre_merge:
             general_argument = general_argument+" --overwrite_is_pre_merge true"

{scriptcollection-3.5.118.dist-info → scriptcollection-3.5.120.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ScriptCollection
-Version: 3.5.118
+Version: 3.5.120
 Summary: The ScriptCollection is the place for reusable scripts.
 Home-page: https://github.com/anionDev/ScriptCollection
 Author: Marius Göcke

scriptcollection-3.5.120.dist-info/RECORD

@@ -0,0 +1,17 @@
+ScriptCollection/CertificateUpdater.py,sha256=OAxrG21k_o3W3niOOGNSZzUPJlvolOWc1lRB2dMhc3g,9212
+ScriptCollection/Executables.py,sha256=ht-RZFu4g34Sr09b_L0c2QpKcjLWX-wFtKSMDMZYqsw,32266
+ScriptCollection/GeneralUtilities.py,sha256=hqAKRF99uu2RCSBgjX4qjYn3IlImwm6rehRvt8hbNFQ,46407
+ScriptCollection/ImageUpdater.py,sha256=lel1nevTN7fgdoCDE6Xg8YY6XPsZaOQiCIyWXbmVnh0,20882
+ScriptCollection/ProcessesRunner.py,sha256=3mu4ZxzZleQo0Op6o9EYTCFiJfb6kx5ov2YfZfT89mU,1395
+ScriptCollection/ProgramRunnerBase.py,sha256=2kMIAqdc65UjBAddOZkzy_aFx9h5roZ5a4bQNM6RV6Y,2480
+ScriptCollection/ProgramRunnerEpew.py,sha256=4pjEd0r9Fcz3TTDv0MdTSd5KkigYXcWUVI1X43regfU,6477
+ScriptCollection/ProgramRunnerPopen.py,sha256=BPY7-ZMIlqT7JOKz8qlB5c0laF2Js-ijzqk09GxZC48,3821
+ScriptCollection/SCLog.py,sha256=lTNw2Th5xvjf9V_pQw6DSsZPdeLAdqOelfZPW8fCC-s,3063
+ScriptCollection/ScriptCollectionCore.py,sha256=9kyDdGMDZNKR7j579zjUSt3vvTLHA-vPw4_Sd2YhWmc,130059
+ScriptCollection/TasksForCommonProjectStructure.py,sha256=4aEuIf89jbgKE4uMYm4DlPDe9Iu1Zujo8wPOzDld09w,234867
+ScriptCollection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scriptcollection-3.5.120.dist-info/METADATA,sha256=PbbVXi9-z9CwClIIuMdlLWkxve1wKz53TMNJYiLsdMA,7694
+scriptcollection-3.5.120.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+scriptcollection-3.5.120.dist-info/entry_points.txt,sha256=3qMbfZEMhc_VTJj-bcLwB8AWcn9iXSB3l0AWpuu52Bs,3689
+scriptcollection-3.5.120.dist-info/top_level.txt,sha256=hY2hOVH0V0Ce51WB76zKkIWTUNwMUdHo4XDkR2vYVwg,17
+scriptcollection-3.5.120.dist-info/RECORD,,

{scriptcollection-3.5.118.dist-info → scriptcollection-3.5.120.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

scriptcollection-3.5.118.dist-info/RECORD

@@ -1,16 +0,0 @@
-ScriptCollection/CertificateUpdater.py,sha256=pJopWFcwaLAEVljtC4O3SVrlpIpoJNUhT1V4mgiqLvE,8970
-ScriptCollection/Executables.py,sha256=ht-RZFu4g34Sr09b_L0c2QpKcjLWX-wFtKSMDMZYqsw,32266
-ScriptCollection/GeneralUtilities.py,sha256=VO4a7xctkjN5dcBXc32gz0x9U07DEagasjvYVKqLmdM,44173
-ScriptCollection/ProcessesRunner.py,sha256=3mu4ZxzZleQo0Op6o9EYTCFiJfb6kx5ov2YfZfT89mU,1395
-ScriptCollection/ProgramRunnerBase.py,sha256=2kMIAqdc65UjBAddOZkzy_aFx9h5roZ5a4bQNM6RV6Y,2480
-ScriptCollection/ProgramRunnerEpew.py,sha256=4pjEd0r9Fcz3TTDv0MdTSd5KkigYXcWUVI1X43regfU,6477
-ScriptCollection/ProgramRunnerPopen.py,sha256=BPY7-ZMIlqT7JOKz8qlB5c0laF2Js-ijzqk09GxZC48,3821
-ScriptCollection/SCLog.py,sha256=5qjOBYiliyHV57GY8Y5dgUek512EVI8AzBF288R4fn4,2377
-ScriptCollection/ScriptCollectionCore.py,sha256=dzrgJteantFqcasor86q7GnhWyfuXk9QX6oWrFCpegg,131693
-ScriptCollection/TasksForCommonProjectStructure.py,sha256=OfCJsg-FLdde6Duhy4FjBcfwLr-9iLhQAimRa1ZgRyE,234045
-ScriptCollection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scriptcollection-3.5.118.dist-info/METADATA,sha256=S2GhphsHV1AG2Skb0k11jlesHhedCLWHWUldstjE3Io,7694
-scriptcollection-3.5.118.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-scriptcollection-3.5.118.dist-info/entry_points.txt,sha256=3qMbfZEMhc_VTJj-bcLwB8AWcn9iXSB3l0AWpuu52Bs,3689
-scriptcollection-3.5.118.dist-info/top_level.txt,sha256=hY2hOVH0V0Ce51WB76zKkIWTUNwMUdHo4XDkR2vYVwg,17
-scriptcollection-3.5.118.dist-info/RECORD,,