ScriptCollection 3.5.119__py3-none-any.whl → 3.5.121__py3-none-any.whl

ScriptCollection/SCLog.py

@@ -5,6 +5,7 @@ from .GeneralUtilities import GeneralUtilities
 
 
 class LogLevel(Enum):
+    Quiet = 0
     Error = 1
     Warning = 2
     Information = 3
@@ -19,10 +20,10 @@ class SCLog:
     log_file: str
     add_overhead: bool
 
-    def __init__(self, log_file: str = None):
-        self.add_overhead = False
-        self.loglevel = LogLevel.Information
+    def __init__(self, log_file: str = None, loglevel: LogLevel = None, add_overhead: bool = False):
         self.log_file = log_file
+        self.loglevel = loglevel
+        self.add_overhead = add_overhead
 
     @GeneralUtilities.check_arguments
     def log_exception(self, message: str, ex: Exception, current_traceback):
@@ -30,41 +31,54 @@ class SCLog:
 
     @GeneralUtilities.check_arguments
     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

@@ -1,4 +1,3 @@
-import sys
 from datetime import timedelta, datetime
 import json
 import binascii
@@ -28,12 +27,13 @@ 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
+from .SCLog import SCLog, LogLevel
 
-version = "3.5.119"
+version = "3.5.121"
 __version__ = version
 
 
@@ -47,11 +47,13 @@ class ScriptCollectionCore:
     __mocked_program_calls: list = None
     program_runner: ProgramRunnerBase = None
     call_program_runner_directly: bool = None
+    log: SCLog = None
 
     def __init__(self):
         self.program_runner = ProgramRunnerPopen()
         self.call_program_runner_directly = None
         self.__mocked_program_calls = list[ScriptCollectionCore.__MockProgramCall]()
+        self.log = SCLog(None, LogLevel.Quiet, False)
 
     @staticmethod
     @GeneralUtilities.check_arguments
@@ -63,7 +65,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 +169,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 +196,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
@@ -428,10 +430,10 @@ class ScriptCollectionCore:
                 self.git_stage_all_changes(directory)
         else:
             if no_changes_behavior == 0:
-                GeneralUtilities.write_message_to_stdout(f"Commit '{message}' will not be done because there are no changes to commit in repository '{directory}'")
+                self.log.log(f"Commit '{message}' will not be done because there are no changes to commit in repository '{directory}'", LogLevel.Debug)
                 do_commit = False
             elif no_changes_behavior == 1:
-                GeneralUtilities.write_message_to_stdout(f"There are no changes to commit in repository '{directory}'. Commit '{message}' will be done anyway.")
+                self.log.log(f"There are no changes to commit in repository '{directory}'. Commit '{message}' will be done anyway.", LogLevel.Debug)
                 do_commit = True
             elif no_changes_behavior == 2:
                 raise RuntimeError(f"There are no changes to commit in repository '{directory}'. Commit '{message}' will not be done.")
@@ -439,7 +441,7 @@ class ScriptCollectionCore:
                 raise ValueError(f"Unknown value for no_changes_behavior: {GeneralUtilities.str_none_safe(no_changes_behavior)}")
 
         if do_commit:
-            GeneralUtilities.write_message_to_stdout(f"Commit changes in '{directory}'")
+            self.log.log(f"Commit changes in '{directory}'", LogLevel.Information)
             self.run_program_argsasarray("git", argument, directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
 
         return self.git_get_commit_id(directory)
@@ -557,19 +559,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
 
@@ -581,7 +583,7 @@ class ScriptCollectionCore:
         counter = 0
         for tag in tags:
             counter = counter+1
-            GeneralUtilities.write_message_to_stdout(f"Process tag {counter}/{tags_count}.")
+            self.log.log(f"Process tag {counter}/{tags_count}.", LogLevel.Information)
             # tag is on source-branch
             if self.git_commit_is_ancestor(repository, tag, tag_source_branch):
                 commit_id_old = self.git_get_commitid_of_tag(repository, tag)
@@ -604,14 +606,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
 
@@ -1048,10 +1050,10 @@ class ScriptCollectionCore:
                 elif (size_string.endswith("gib")):
                     size = int(size_string[:-3]) * pow(2, 30)
                 else:
-                    GeneralUtilities.write_message_to_stderr("Wrong format")
+                    self.log.log("Wrong format", LogLevel.Error)
                     return 1
             else:
-                GeneralUtilities.write_message_to_stderr("Wrong format")
+                self.log.log("Wrong format", LogLevel.Error)
                 return 1
         with open(name, "wb") as f:
             f.seek(size-1)
@@ -1115,7 +1117,7 @@ class ScriptCollectionCore:
 
             return 0
         else:
-            GeneralUtilities.write_message_to_stdout(f"File '{file}' does not exist")
+            self.log.log(f"File '{file}' does not exist.", LogLevel.Error)
             return 1
 
     @GeneralUtilities.check_arguments
@@ -1194,8 +1196,7 @@ class ScriptCollectionCore:
     @GeneralUtilities.check_arguments
     def __print_qr_code_by_csv_line(self, displayname: str, website: str, emailaddress: str, key: str, period: str) -> None:
         qrcode_content = f"otpauth://totp/{website}:{emailaddress}?secret={key}&issuer={displayname}&period={period}"
-        GeneralUtilities.write_message_to_stdout(
-            f"{displayname} ({emailaddress}):")
+        GeneralUtilities.write_message_to_stdout(f"{displayname} ({emailaddress}):")
         GeneralUtilities.write_message_to_stdout(qrcode_content)
         qr = qrcode.QRCode()
         qr.add_data(qrcode_content)
@@ -1243,7 +1244,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
 
@@ -1447,9 +1448,8 @@ class ScriptCollectionCore:
         ls_result = self.run_program_argsasarray("ls", ["-ld", file_or_folder])
         GeneralUtilities.assert_condition(ls_result[0] == 0, f"'ls -ld {file_or_folder}' resulted in exitcode {str(ls_result[0])}. StdErr: {ls_result[2]}")
         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
 
@@ -1460,7 +1460,6 @@ class ScriptCollectionCore:
         ls_result = self.run_program_argsasarray("ls", ["-la", file_or_folder])
         GeneralUtilities.assert_condition(ls_result[0] == 0, f"'ls -la {file_or_folder}' resulted in exitcode {str(ls_result[0])}. StdErr: {ls_result[2]}")
         GeneralUtilities.assert_condition(not GeneralUtilities.string_is_none_or_whitespace(ls_result[1]), f"'ls -la' 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.split("\n")[3:]  # skip the lines with "Total", "." and ".."
         result = [' '.join(line.split()) for line in result]  # reduce multiple whitespaces to one
@@ -1520,7 +1519,7 @@ class ScriptCollectionCore:
         return False
 
     @staticmethod
-    def __read_popen_pipes(p: Popen, print_live_output: bool, print_errors_as_information: bool) -> tuple[list[str], list[str]]:
+    def __read_popen_pipes(p: Popen, print_live_output: bool, print_errors_as_information: bool, log: SCLog) -> tuple[list[str], list[str]]:
         p_id = p.pid
         with ThreadPoolExecutor(2) as pool:
             q_stdout = Queue()
@@ -1538,31 +1537,33 @@ 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
                             if print_live_output:
-                                print(out_line, end='\n', file=sys.stdout, flush=False)
-                    if print_live_output:
-                        sys.stdout.flush()
+                                # print(out_line, end='\n', file=sys.stdout, flush=False)
+                                log.log(out_line+"\n", LogLevel.Information)
+                    # if print_live_output:
+                    #    sys.stdout.flush()
                 except Empty:
                     reading_stdout_last_time_resulted_in_exception = True
 
                 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
                             if print_live_output:
-                                print(err_line, end='\n', file=sys.stdout if print_errors_as_information else sys.stderr, flush=False)
-                    if print_live_output:
-                        if print_errors_as_information:
-                            sys.stdout.flush()
-                        else:
-                            sys.stderr.flush()
+                                # print(err_line, end='\n', file=sys.stdout if print_errors_as_information else sys.stderr, flush=False)
+                                log.log(err_line+"\n", LogLevel.Error if print_errors_as_information else LogLevel.Information)
+                    # if print_live_output:
+                    #    if print_errors_as_information:
+                    #        sys.stdout.flush()
+                    #    else:
+                    #        sys.stderr.flush()
                 except Empty:
                     reading_stderr_last_time_resulted_in_exception = True
 
@@ -1597,11 +1598,11 @@ class ScriptCollectionCore:
 
             verbose = verbosity > 2
             if verbose:
-                GeneralUtilities.write_message_to_stdout(f"Run '{info_for_log}'.")
+                self.log.log(f"Run '{info_for_log}'.", LogLevel.Debug)
 
             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:
@@ -1610,7 +1611,7 @@ class ScriptCollectionCore:
                     GeneralUtilities.ensure_file_exists(log_file)
                 pid = process.pid
 
-                outputs: tuple[list[str], list[str]] = ScriptCollectionCore.__read_popen_pipes(process, print_live_output, print_errors_as_information)
+                outputs: tuple[list[str], list[str]] = ScriptCollectionCore.__read_popen_pipes(process, print_live_output, print_errors_as_information, self.log)
 
                 for out_line_plain in outputs[0]:
                     if out_line_plain is not None:
@@ -1655,7 +1656,7 @@ class ScriptCollectionCore:
             result_message = f"Program '{info_for_log}' resulted in exitcode {exit_code}."
 
             if verbose:
-                GeneralUtilities.write_message_to_stdout(result_message)
+                self.log.log(result_message, LogLevel.Debug)
 
             if throw_exception_if_exitcode_is_not_zero and exit_code != 0:
                 raise ValueError(f"{result_message} (StdOut: '{stdout}', StdErr: '{stderr}')")
@@ -1969,56 +1970,16 @@ DNS                 = {domain}
     def update_dependencies_of_dotnet_project(self, csproj_file: str, verbosity: int, ignored_dependencies: list[str]):
         folder = os.path.dirname(csproj_file)
         csproj_filename = os.path.basename(csproj_file)
-        GeneralUtilities.write_message_to_stdout(f"Check for updates in {csproj_filename}")
+        self.log.log(f"Check for updates in {csproj_filename}", LogLevel.Information)
         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.log.log(f"Update package {package_name}...", LogLevel.Debug)
                     self.run_program("dotnet", f"add {csproj_filename} package {package_name}", folder, print_errors_as_information=True)
 
-    @GeneralUtilities.check_arguments
-    def dotnet_package_is_available(self, package_name: str, package_version: str, source: str):
-        default_source_address = "nuget.org"
-        if source == default_source_address:
-            GeneralUtilities.write_message_to_stdout(f"Wait until package {package_name} v{package_version} is available on {source}.")
-            headers = {'Cache-Control': 'no-cache'}
-            r = requests.get(f"https://api.{default_source_address}/v3-flatcontainer/{package_name.lower()}/{package_version}/{package_name.lower()}.nuspec", timeout=5, headers=headers)
-            return r.status_code == 200
-        else:
-            raise ValueError(f"dotnet_package_is_available is not implemented yet for other sources than {default_source_address}.")
-
-    @GeneralUtilities.check_arguments
-    def wait_until_dotnet_package_is_available(self, package_name: str, package_version: str, source: str):
-        return  # TODO fix this
-        try:  # pylint: disable=unreachable
-            while not self.dotnet_package_is_available(package_name, package_version, source):
-                time.sleep(30)
-        except:
-            pass
-
-    @GeneralUtilities.check_arguments
-    def python_package_is_available(self, package_name: str, package_version: str, source: str):
-        default_source_address = "pypi.org"
-        if source == default_source_address:
-            GeneralUtilities.write_message_to_stdout(f"Wait until package {package_name} v{package_version} is available on {source}.")
-            headers = {'Cache-Control': 'no-cache'}
-            r = requests.get(f"https://{default_source_address}/pypi/{package_name}/{package_version}/json", timeout=5, headers=headers)
-            return r.status_code == 200
-        else:
-            raise ValueError(f"python_package_is_available is not implemented yet for other sources than {default_source_address}.")
-
-    @GeneralUtilities.check_arguments
-    def wait_until_python_package_is_available(self, package_name: str, package_version: str, source: str):
-        return  # TODO fix this
-        try:  # pylint: disable=unreachable
-            while not self.python_package_is_available(package_name, package_version, source):
-                time.sleep(30)
-        except:
-            pass
-
     @GeneralUtilities.check_arguments
     def create_deb_package(self, toolname: str, binary_folder: str, control_file_content: str, deb_output_folder: str, verbosity: int, permission_of_executable_file_as_octet_triple: int) -> None:
 
@@ -2330,47 +2291,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")