ScriptCollection 3.3.23__py3-none-any.whl → 4.0.78__py3-none-any.whl

ScriptCollection/TFCPS/Flutter/TFCPS_CodeUnitSpecific_Flutter.py

@@ -0,0 +1,130 @@
+import os
+import shutil
+import re
+import zipfile
+from ...GeneralUtilities import GeneralUtilities
+from ...SCLog import  LogLevel
+from ..TFCPS_CodeUnitSpecific_Base import TFCPS_CodeUnitSpecific_Base,TFCPS_CodeUnitSpecific_Base_CLI
+
+class TFCPS_CodeUnitSpecific_Flutter_Functions(TFCPS_CodeUnitSpecific_Base):
+ 
+    def __init__(self,current_file:str,verbosity:LogLevel,targetenvironmenttype:str,use_cache:bool,is_pre_merge:bool):
+        super().__init__(current_file, verbosity,targetenvironmenttype,use_cache,is_pre_merge)
+
+
+    @GeneralUtilities.check_arguments
+    def build(self,package_name:str,targets:list[str]) -> None:
+        codeunit_folder = self.get_codeunit_folder()
+        codeunit_name = os.path.basename(codeunit_folder)
+        src_folder: str = None
+        if package_name is None:
+            src_folder = codeunit_folder
+        else:
+            src_folder = GeneralUtilities.resolve_relative_path(package_name, codeunit_folder)  # TODO replace packagename
+        artifacts_folder = os.path.join(codeunit_folder, "Other", "Artifacts")
+        
+        target_names: dict[str, str] = {
+            "web": "WebApplication",
+            "windows": "Windows",
+            "ios": "IOS",
+            "appbundle": "Android",
+        }
+        for target in targets:
+            self._protected_sc.log.log(f"Build flutter-codeunit {codeunit_name} for target {target_names[target]}...")
+            self._protected_sc.run_with_epew("flutter", f"build {target}", src_folder)
+            if target == "web":
+                web_relase_folder = os.path.join(src_folder, "build/web")
+                web_folder = os.path.join(artifacts_folder, "BuildResult_WebApplication")
+                GeneralUtilities.ensure_directory_does_not_exist(web_folder)
+                GeneralUtilities.ensure_directory_exists(web_folder)
+                GeneralUtilities.copy_content_of_folder(web_relase_folder, web_folder)
+            elif target == "windows":
+                windows_release_folder = os.path.join(src_folder, "build/windows/x64/runner/Release")
+                windows_folder = os.path.join(artifacts_folder, "BuildResult_Windows")
+                GeneralUtilities.ensure_directory_does_not_exist(windows_folder)
+                GeneralUtilities.ensure_directory_exists(windows_folder)
+                GeneralUtilities.copy_content_of_folder(windows_release_folder, windows_folder)
+            elif target == "ios":
+                raise ValueError("building for ios is not implemented yet")
+            elif target == "appbundle":
+                aab_folder = os.path.join(artifacts_folder, "BuildResult_AAB")
+                GeneralUtilities.ensure_directory_does_not_exist(aab_folder)
+                GeneralUtilities.ensure_directory_exists(aab_folder)
+                aab_relase_folder = os.path.join(src_folder, "build/app/outputs/bundle/release")
+                aab_file_original = self._protected_sc.find_file_by_extension(aab_relase_folder, "aab")
+                aab_file = os.path.join(aab_folder, f"{codeunit_name}.aab")
+                shutil.copyfile(aab_file_original, aab_file)
+                
+                bundletool = self.tfcps_Tools_General.ensure_androidappbundletool_is_available(None,self.use_cache())
+                apk_folder = os.path.join(artifacts_folder, "BuildResult_APK")
+                GeneralUtilities.ensure_directory_does_not_exist(apk_folder)
+                GeneralUtilities.ensure_directory_exists(apk_folder)
+                apks_file = f"{apk_folder}/{codeunit_name}.apks"
+                self._protected_sc.run_program("java", f"-jar {bundletool} build-apks --bundle={aab_file} --output={apks_file} --mode=universal", aab_relase_folder)
+                with zipfile.ZipFile(apks_file, "r") as zip_ref:
+                    zip_ref.extract("universal.apk", apk_folder)
+                GeneralUtilities.ensure_file_does_not_exist(apks_file)
+                os.rename(f"{apk_folder}/universal.apk", f"{apk_folder}/{codeunit_name}.apk")
+            else:
+                raise ValueError(f"Not supported target: {target}")
+        self.copy_source_files_to_output_directory()
+
+    @GeneralUtilities.check_arguments
+    def linting(self) -> None:
+        pass#TODO
+
+    @GeneralUtilities.check_arguments
+    def do_common_tasks(self,current_codeunit_version:str )-> None:
+        self.do_common_tasks_base(current_codeunit_version)
+
+    @GeneralUtilities.check_arguments
+    def generate_reference(self) -> None:
+        self.generate_reference_using_docfx()
+
+    
+    @GeneralUtilities.check_arguments
+    def run_testcases(self,package_name:str) -> None:
+        codeunit_folder = self.get_codeunit_folder()
+        repository_folder = GeneralUtilities.resolve_relative_path("..", codeunit_folder)
+        codeunit_name = os.path.basename(codeunit_folder)
+        src_folder = GeneralUtilities.resolve_relative_path(package_name, codeunit_folder)
+        
+        self._protected_sc.run_with_epew("flutter", "test --coverage", src_folder)
+        test_coverage_folder_relative = "Other/Artifacts/TestCoverage"
+        test_coverage_folder = GeneralUtilities.resolve_relative_path(test_coverage_folder_relative, codeunit_folder)
+        GeneralUtilities.ensure_directory_exists(test_coverage_folder)
+        coverage_file_relative = f"{test_coverage_folder_relative}/TestCoverage.xml"
+        coverage_file = GeneralUtilities.resolve_relative_path(coverage_file_relative, codeunit_folder)
+        self._protected_sc.run_with_epew("lcov_cobertura", f"coverage/lcov.info --base-dir . --excludes test --output ../{coverage_file_relative} --demangle", src_folder)
+
+        # format correctly
+        content = GeneralUtilities.read_text_from_file(coverage_file)
+        content = re.sub('<![^<]+>', '', content)
+        content = re.sub('\\\\', '/', content)
+        content = re.sub('\\ name=\\"lib\\"', '', content)
+        content = re.sub('\\ filename=\\"lib/', f' filename="{package_name}/lib/', content)
+        GeneralUtilities.write_text_to_file(coverage_file, content)
+        self.tfcps_Tools_General.merge_packages(coverage_file, self.get_codeunit_name())
+        self.tfcps_Tools_General.calculate_entire_line_rate(coverage_file)
+        self.run_testcases_common_post_task(repository_folder, codeunit_name, True, self.get_target_environment_type())
+    
+    
+    def get_dependencies(self)->dict[str,set[str]]:
+        return []#TODO
+    
+    @GeneralUtilities.check_arguments
+    def get_available_versions(self,dependencyname:str)->list[str]:
+        return []#TODO
+    
+    def set_dependency_version(self,name:str,new_version:str)->None:
+        raise ValueError(f"Operation is not implemented.")
+    
+class TFCPS_CodeUnitSpecific_Flutter_CLI:
+
+    @staticmethod
+    def parse(file:str)->TFCPS_CodeUnitSpecific_Flutter_Functions:
+        parser=TFCPS_CodeUnitSpecific_Base_CLI.get_base_parser()
+        #add custom parameter if desired
+        args=parser.parse_args()
+        result:TFCPS_CodeUnitSpecific_Flutter_Functions=TFCPS_CodeUnitSpecific_Flutter_Functions(file,LogLevel(int(args.verbosity)),args.targetenvironmenttype,not args.nocache,args.ispremerge)
+        return result

ScriptCollection/TFCPS/Go/TFCPS_CodeUnitSpecific_Go.py

@@ -0,0 +1,74 @@
+import os
+from lxml import etree
+from ...GeneralUtilities import GeneralUtilities
+from ...ScriptCollectionCore import ScriptCollectionCore
+from ...SCLog import  LogLevel
+from ..TFCPS_CodeUnitSpecific_Base import TFCPS_CodeUnitSpecific_Base,TFCPS_CodeUnitSpecific_Base_CLI
+
+class TFCPS_CodeUnitSpecific_Go_Functions(TFCPS_CodeUnitSpecific_Base):
+
+    def __init__(self,current_file:str,verbosity:LogLevel,targetenvironmenttype:str,use_cache:bool,is_pre_merge:bool):
+        super().__init__(current_file, verbosity,targetenvironmenttype,use_cache,is_pre_merge)
+
+    @GeneralUtilities.check_arguments
+    def build(self) -> None:
+        #TODO
+        self.__generate_sbom_for_go_image()
+
+    @GeneralUtilities.check_arguments
+    def __generate_sbom_for_go_image(self) -> None:
+        pass#TODO
+
+    @GeneralUtilities.check_arguments
+    def linting(self) -> None:
+        pass#TODO
+
+    @GeneralUtilities.check_arguments
+    def __update_coverage_file(self,coverage_file:str) -> None:
+        tree = etree.parse(coverage_file)
+        root = tree.getroot()
+        for package in root.findall(".//package"):
+            package.set("name",self.get_codeunit_name())
+        for cls in root.findall(".//class"):
+            filename = cls.get("filename")
+            if filename:
+                cls.set("filename", f"./{filename}")
+            cls.set("name",str(filename).rsplit("/", 1)[-1])
+        tree.write(coverage_file, encoding="utf-8", xml_declaration=True, pretty_print=True)
+
+    @GeneralUtilities.check_arguments
+    def run_testcases(self) -> None:
+        test_coverage_folder = os.path.join(self.get_codeunit_folder(), "Other", "Artifacts", "TestCoverage").replace("\\", "/")
+        GeneralUtilities.ensure_directory_exists(test_coverage_folder)
+        src_folder = GeneralUtilities.resolve_relative_path(self.get_codeunit_name(), self.get_codeunit_folder())
+        sc: ScriptCollectionCore = ScriptCollectionCore()
+        sc.run_program_argsasarray("go", ["install", "github.com/t-yuki/gocover-cobertura@latest"], src_folder)
+        sc.run_program_argsasarray("go", ["test", "-coverprofile=coverage.out", "./..."], src_folder)
+        coverage_file:str=f"{test_coverage_folder}/TestCoverage.xml"
+        sc.run_program_argsasarray("sh", ["-c", f"gocover-cobertura < coverage.out > {coverage_file}"], src_folder)
+        self.__update_coverage_file(coverage_file)
+        self.run_testcases_common_post_task(self.get_repository_folder(),self.get_codeunit_name(),True,self.get_type_environment_type())
+
+    def get_dependencies(self)->dict[str,set[str]]:
+        return []#TODO
+    
+    @GeneralUtilities.check_arguments
+    def get_available_versions(self,dependencyname:str)->list[str]:
+        return []#TODO
+    
+    def set_dependency_version(self,name:str,new_version:str)->None:
+        raise ValueError(f"Operation is not implemented.")
+    
+class TFCPS_CodeUnitSpecific_Go_CLI:
+
+    @staticmethod
+    def parse(file:str)->TFCPS_CodeUnitSpecific_Go_Functions:
+        parser=TFCPS_CodeUnitSpecific_Base_CLI.get_base_parser()
+        #add custom parameter if desired
+        args=parser.parse_args()
+        result:TFCPS_CodeUnitSpecific_Go_Functions=TFCPS_CodeUnitSpecific_Go_Functions(file,LogLevel(int(args.verbosity)),args.targetenvironmenttype,not args.nocache,args.ispremerge)
+        return result
+
+def run_testcases():
+    t :TFCPS_CodeUnitSpecific_Go_Functions= TFCPS_CodeUnitSpecific_Go_CLI().parse(__file__)
+    t.run_testcases()

ScriptCollection/TFCPS/NodeJS/TFCPS_CodeUnitSpecific_NodeJS.py

@@ -0,0 +1,131 @@
+import os
+import re
+from lxml import etree
+from ...GeneralUtilities import GeneralUtilities
+from ...SCLog import  LogLevel
+from ..TFCPS_CodeUnitSpecific_Base import TFCPS_CodeUnitSpecific_Base,TFCPS_CodeUnitSpecific_Base_CLI
+
+class TFCPS_CodeUnitSpecific_NodeJS_Functions(TFCPS_CodeUnitSpecific_Base):
+
+
+    def __init__(self,current_file:str,verbosity:LogLevel,targetenvironmenttype:str,use_cache:bool,is_pre_merge:bool):
+        super().__init__(current_file, verbosity,targetenvironmenttype,use_cache,is_pre_merge)
+
+
+    @GeneralUtilities.check_arguments
+    def build(self) -> None:
+        self._protected_sc.run_with_epew("npm", "run build", self.get_codeunit_folder(),print_live_output=self._protected_sc.log.loglevel==LogLevel.Diagnostic,encode_argument_in_base64=True)
+        self.standardized_tasks_build_bom_for_node_project()
+        self.copy_source_files_to_output_directory()
+
+    @GeneralUtilities.check_arguments
+    def linting(self) -> None:
+        self._protected_sc.run_with_epew("npm", "run lint", self.get_codeunit_folder(),print_live_output=self._protected_sc.log.loglevel==LogLevel.Diagnostic,encode_argument_in_base64=True)
+
+    @GeneralUtilities.check_arguments
+    def do_common_tasks(self,current_codeunit_version:str)-> None:
+        codeunit_version = current_codeunit_version
+        codeunit_folder = self.get_codeunit_folder()
+        self.do_common_tasks_base(current_codeunit_version)
+        self.tfcps_Tools_General.replace_version_in_packagejson_file(GeneralUtilities.resolve_relative_path("./package.json", codeunit_folder), codeunit_version)
+        self.tfcps_Tools_General.do_npm_install(codeunit_folder, True,self.use_cache())
+        #if generateAPIClientBase.generate_api_client():
+        #    generateAPIClientGenerate:GenerateAPIClientGenerate=generateAPIClientBase
+        #    self.tfcps_Tools_General.generate_api_client_from_dependent_codeunit_in_angular(codeunit_folder, generateAPIClientGenerate.name_of_api_providing_codeunit,generateAPIClientGenerate.generate_api_client)
+  
+    @GeneralUtilities.check_arguments
+    def generate_reference(self) -> None:
+        self.generate_reference_using_docfx()
+
+    
+    @GeneralUtilities.check_arguments
+    def run_testcases(self) -> None:
+        # prepare
+        codeunit_name: str =self.get_codeunit_name()
+        
+        codeunit_folder =self.get_codeunit_folder()
+        repository_folder = os.path.dirname(codeunit_folder)
+
+        # run testcases
+        self._protected_sc.run_with_epew("npm", f"run test-{self.get_target_environment_type()}", self.get_codeunit_folder(),print_live_output=self._protected_sc.log.loglevel==LogLevel.Diagnostic,encode_argument_in_base64=True)
+
+        # rename file
+        coverage_folder = os.path.join(codeunit_folder, "Other", "Artifacts", "TestCoverage")
+        target_file = os.path.join(coverage_folder, "TestCoverage.xml")
+        GeneralUtilities.ensure_file_does_not_exist(target_file)
+        os.rename(os.path.join(coverage_folder, "cobertura-coverage.xml"), target_file)
+        self.__rename_packagename_in_coverage_file(target_file, codeunit_name)
+
+        # adapt backslashs to slashs
+        content = GeneralUtilities.read_text_from_file(target_file)
+        content = re.sub('\\\\', '/', content)
+        GeneralUtilities.write_text_to_file(target_file, content)
+
+        # aggregate packages in testcoverage-file
+        roottree: etree._ElementTree = etree.parse(target_file)
+        existing_classes = list(roottree.xpath('//coverage/packages/package/classes/class'))
+
+        old_packages_list = roottree.xpath('//coverage/packages/package')
+        for package in old_packages_list:
+            package.getparent().remove(package)
+
+        root = roottree.getroot()
+        packages_element = root.find("packages")
+        package_element = etree.SubElement(packages_element, "package")
+        package_element.attrib['name'] = codeunit_name
+        package_element.attrib['lines-valid'] = root.attrib["lines-valid"]
+        package_element.attrib['lines-covered'] = root.attrib["lines-covered"]
+        package_element.attrib['line-rate'] = root.attrib["line-rate"]
+        package_element.attrib['branches-valid'] = root.attrib["branches-valid"]
+        package_element.attrib['branches-covered'] = root.attrib["branches-covered"]
+        package_element.attrib['branch-rate'] = root.attrib["branch-rate"]
+        package_element.attrib['timestamp'] = root.attrib["timestamp"]
+        package_element.attrib['complexity'] = root.attrib["complexity"]
+
+        classes_element = etree.SubElement(package_element, "classes")
+
+        for existing_class in existing_classes:
+            classes_element.append(existing_class)
+
+        result = etree.tostring(roottree, pretty_print=True).decode("utf-8")
+        GeneralUtilities.write_text_to_file(target_file, result)
+
+        # post tasks
+        self.run_testcases_common_post_task(repository_folder, codeunit_name, True, self.get_target_environment_type())
+
+    @GeneralUtilities.check_arguments
+    def __rename_packagename_in_coverage_file(self, file: str, codeunit_name: str) -> None:
+        root: etree._ElementTree = etree.parse(file)
+        packages = root.xpath('//coverage/packages/package')
+        for package in packages:
+            package.attrib['name'] = codeunit_name
+        result = etree.tostring(root).decode("utf-8")
+        GeneralUtilities.write_text_to_file(file, result)
+
+
+    @GeneralUtilities.check_arguments 
+    def standardized_tasks_build_bom_for_node_project(self) -> None:
+        relative_path_to_bom_file = f"Other/Artifacts/BOM/{os.path.basename(self.get_codeunit_folder())}.{self.tfcps_Tools_General.get_version_of_codeunit(self.get_codeunit_file())}.sbom.xml"
+        self._protected_sc.run_with_epew("cyclonedx-npm", f"--output-format xml --output-file {relative_path_to_bom_file}", self.get_codeunit_folder(),print_live_output=self._protected_sc.log.loglevel==LogLevel.Diagnostic,encode_argument_in_base64=True)
+        self._protected_sc.format_xml_file(self.get_codeunit_folder()+"/"+relative_path_to_bom_file)
+
+    
+    def get_dependencies(self)->dict[str,set[str]]:
+        return []#TODO
+    
+    @GeneralUtilities.check_arguments
+    def get_available_versions(self,dependencyname:str)->list[str]:
+        return []#TODO
+    
+    def set_dependency_version(self,name:str,new_version:str)->None:
+        raise ValueError(f"Operation is not implemented.")
+    
+class TFCPS_CodeUnitSpecific_NodeJS_CLI:
+ 
+    @staticmethod
+    def parse(file:str)->TFCPS_CodeUnitSpecific_NodeJS_Functions:
+        parser=TFCPS_CodeUnitSpecific_Base_CLI.get_base_parser()
+        #add custom parameter if desired
+        args=parser.parse_args()
+        result:TFCPS_CodeUnitSpecific_NodeJS_Functions=TFCPS_CodeUnitSpecific_NodeJS_Functions(file,LogLevel(int(args.verbosity)),args.targetenvironmenttype,not args.nocache,args.ispremerge)
+        return result

ScriptCollection/TFCPS/Python/TFCPS_CodeUnitSpecific_Python.py

@@ -0,0 +1,227 @@
+import os
+import re
+from ...GeneralUtilities import GeneralUtilities,Dependency
+from ...SCLog import  LogLevel
+from ..TFCPS_CodeUnitSpecific_Base import TFCPS_CodeUnitSpecific_Base,TFCPS_CodeUnitSpecific_Base_CLI
+
+class TFCPS_CodeUnitSpecific_Python_Functions(TFCPS_CodeUnitSpecific_Base):
+
+    def __init__(self,current_file:str,verbosity:LogLevel,targetenvironmenttype:str,use_cache:bool,is_pre_merge:bool):
+        super().__init__(current_file, verbosity,targetenvironmenttype,use_cache,is_pre_merge)
+ 
+
+    @GeneralUtilities.check_arguments
+    def build(self) -> None:
+        codeunit_folder = self.get_codeunit_folder()
+        target_directory = GeneralUtilities.resolve_relative_path("../Artifacts/BuildResult_Wheel", os.path.join(self.get_artifacts_folder()))
+        GeneralUtilities.ensure_directory_exists(target_directory)
+        self._protected_sc.run_program("python", f"-m build --wheel --outdir {target_directory}", codeunit_folder)
+        self.generate_bom_for_python_project( )
+        self.copy_source_files_to_output_directory()
+
+    @GeneralUtilities.check_arguments
+    def generate_bom_for_python_project(self) -> None:
+        codeunit_folder: str=self.get_codeunit_folder()
+        codeunitname: str=self.get_codeunit_name()
+        repository_folder = os.path.dirname(codeunit_folder) 
+        
+        codeunitversion = self.tfcps_Tools_General.get_version_of_codeunit(self.get_codeunit_file())
+        bom_folder = "Other/Artifacts/BOM"
+        bom_folder_full = os.path.join(codeunit_folder, bom_folder)
+        GeneralUtilities.ensure_directory_exists(bom_folder_full)
+        if not os.path.isfile(os.path.join(codeunit_folder, "requirements.txt")):
+            raise ValueError(f"Codeunit {codeunitname} does not have a 'requirements.txt'-file.")
+        # TODO check that all values from setup.cfg are contained in requirements.txt
+        result = self._protected_sc.run_program("cyclonedx-py", "requirements", codeunit_folder)
+        bom_file_relative_json = f"{bom_folder}/{codeunitname}.{codeunitversion}.bom.json"
+        bom_file_relative_xml = f"{bom_folder}/{codeunitname}.{codeunitversion}.bom.xml"
+        bom_file_json = os.path.join(codeunit_folder, bom_file_relative_json)
+        bom_file_xml = os.path.join(codeunit_folder, bom_file_relative_xml)
+
+        GeneralUtilities.ensure_file_exists(bom_file_json)
+        GeneralUtilities.write_text_to_file(bom_file_json, result[1])
+        cyclonedx_exe=self.tfcps_Tools_General.ensure_cyclonedxcli_is_available(repository_folder,not self.use_cache())
+        self._protected_sc.run_program(cyclonedx_exe, f"convert --input-file ./{codeunitname}/{bom_file_relative_json} --input-format json --output-file ./{codeunitname}/{bom_file_relative_xml} --output-format xml", repository_folder)
+        self._protected_sc.format_xml_file(bom_file_xml)
+        GeneralUtilities.ensure_file_does_not_exist(bom_file_json)
+
+    @GeneralUtilities.check_arguments
+    def linting(self) -> None:
+        codeunitname: str = self.get_codeunit_name()
+        
+        repository_folder: str = self.get_repository_folder()
+        errors_found = False
+        self._protected_sc.log.log(f"Check for linting-issues in codeunit {codeunitname}.")
+        src_folder = os.path.join(repository_folder, codeunitname, codeunitname)
+        tests_folder = src_folder+"Tests"
+        # TODO check if there are errors in sarif-file
+        for file in GeneralUtilities.get_all_files_of_folder(src_folder)+GeneralUtilities.get_all_files_of_folder(tests_folder):
+            relative_file_path_in_repository = os.path.relpath(file, repository_folder)
+            if file.endswith(".py") and os.path.getsize(file) > 0 and not self._protected_sc.file_is_git_ignored(relative_file_path_in_repository, repository_folder):
+                self._protected_sc.log.log(f"Check for linting-issues in {os.path.relpath(file, os.path.join(repository_folder, codeunitname))}.")
+                linting_result = self._protected_sc.python_file_has_errors(file, repository_folder)
+                if (linting_result[0]):
+                    errors_found = True
+                    for error in linting_result[1]:
+                        self._protected_sc.log.log(error, LogLevel.Warning)
+        if errors_found:
+            raise ValueError("Linting-issues occurred.")
+        else:
+            self._protected_sc.log.log("No linting-issues found.")
+
+    @GeneralUtilities.check_arguments
+    def do_common_tasks(self,current_codeunit_version:str )-> None:
+        self.do_common_tasks_base(current_codeunit_version)
+        codeunitname =self.get_codeunit_name()
+        codeunit_version = self.tfcps_Tools_General.get_version_of_project(self.get_repository_folder()) 
+        self._protected_sc.replace_version_in_ini_file(GeneralUtilities.resolve_relative_path("./setup.cfg", self.get_codeunit_folder()), codeunit_version)
+        self._protected_sc.replace_version_in_python_file(GeneralUtilities.resolve_relative_path(f"./{codeunitname}/{codeunitname}Core.py", self.get_codeunit_folder()), codeunit_version)
+
+    @GeneralUtilities.check_arguments
+    def generate_reference(self) -> None:
+        self.generate_reference_using_docfx()
+
+    @GeneralUtilities.check_arguments
+    def run_testcases(self) -> None:
+        codeunitname: str =self.get_codeunit_name()
+        repository_folder: str = self.get_repository_folder()
+        codeunit_folder = os.path.join(repository_folder, codeunitname)
+        self._protected_sc.run_program("coverage", f"run -m pytest -s ./{codeunitname}Tests", codeunit_folder)
+        self._protected_sc.run_program("coverage", "xml", codeunit_folder)
+        coveragefolder = os.path.join(repository_folder, codeunitname, "Other/Artifacts/TestCoverage")
+        GeneralUtilities.ensure_directory_exists(coveragefolder)
+        coveragefile = os.path.join(coveragefolder, "TestCoverage.xml")
+        GeneralUtilities.ensure_file_does_not_exist(coveragefile)
+        os.rename(os.path.join(repository_folder, codeunitname, "coverage.xml"), coveragefile)
+        self.tfcps_Tools_General.merge_packages(coveragefile,codeunitname)
+        self.run_testcases_common_post_task(repository_folder, codeunitname, True, self.get_type_environment_type())
+
+    def get_dependencies(self)->dict[str,set[str]]:
+        return GeneralUtilities.merge_dependency_lists([
+            self.get_dependencies_from_setupcfg(),
+            self.get_dependencies_from_requirementstxt(),
+            self.get_dependencies_from_otherrequirementstxt()
+        ])
+    
+    def get_dependencies_from_setupcfg(self)->list[Dependency]:
+        setupcfg_file=os.path.join(self.get_codeunit_folder(),"setup.cfg")
+        lines = GeneralUtilities.read_lines_from_file(setupcfg_file)
+        result:list[Dependency]=[]
+        is_in_dependency_section=False
+        for line in lines:
+            if line=="install_requires =":
+                is_in_dependency_section=True
+            elif line.startswith(" "):
+                if is_in_dependency_section:
+                    match = re.match(r"^\s*([A-Za-z0-9_\-]+)\s*([<>=!~]+)?\s*(.*)?$", line)
+                    if match:
+                        dep_name = match.group(1)
+                        dep_operator = match.group(2) or None#pylint:disable=unused-variable
+                        dep_version = match.group(3) or None
+                        dep=Dependency(dep_name,dep_version)
+                        result.append(dep)
+                    else:
+                        raise ValueError(f"Unparsable dependency-definition-line: \"{line}\"")
+            else:
+                is_in_dependency_section=False
+        return result
+    
+    def get_dependencies_from_requirementstxt(self)->list[Dependency]:
+        return self.get_dependencies_from_requirementsfile(os.path.join(self.get_codeunit_folder(),"requirements.txt")) 
+    
+    def get_dependencies_from_otherrequirementstxt(self)->list[Dependency]:
+        rfile=os.path.join(self.get_codeunit_folder(),"Other","requirements.txt")
+        if os.path.isfile(rfile):
+            return self.get_dependencies_from_requirementsfile(rfile) 
+        else:
+            return []
+    
+    def get_dependencies_from_requirementsfile(self,file:str)->list[Dependency]:
+        lines = GeneralUtilities.read_lines_from_file(file)
+        result:list[Dependency]=[]
+        for line in lines:
+            match = re.match(r"^([A-Za-z0-9_\-]+)\s*([<>=!~]+)?\s*(.*)?$", line)
+            if match:
+                dep_name = match.group(1)
+                dep_operator = match.group(2) or None#pylint:disable=unused-variable
+                dep_version = match.group(3) or None
+                dep=Dependency(dep_name,dep_version)
+                result.append(dep)
+
+        return result
+    
+    @GeneralUtilities.check_arguments
+    def get_available_versions(self,dependencyname:str)->list[str]:
+        result=self._protected_sc.run_program("pip3",f"index versions {dependencyname}")
+        available_versions_line:str=[line for line in GeneralUtilities.string_to_lines(result[1]) if line.startswith("Available versions: ")][0]
+        available_versions=[version_str.strip() for version_str in available_versions_line[len("Available versions: "):].split(",")]
+        result=[]
+        for v in available_versions:
+            if re.match(r"^(\d+).(\d+).(\d+)$", v) is not None:
+                result.append(v)
+            elif re.match(r"^(\d+).(\d+)$", v) is not None:
+                result.append(v+".0")
+            elif re.match(r"^(\d+)$", v) is not None:
+                result.append(v+".0.0")
+        return result
+    
+    def set_dependency_version(self,name:str,new_version:str)->None:
+        self.__set_dependency_version_in_setupcfg(name,new_version)
+        self.__set_dependency_version_in_requirementstxt(name,new_version)
+        self.__set_dependency_version_in_otherrequirementstxt(name,new_version)
+
+    def __set_dependency_version_in_setupcfg(self,name:str,new_version:str)->None:
+        setupcfg_file=os.path.join(self.get_codeunit_folder(),"setup.cfg")
+        lines=GeneralUtilities.read_lines_from_file(setupcfg_file)
+        new_lines:list[str]=[]
+        for line in lines:
+            match = re.match("^(\\s*)("+re.escape(name)+")\\s*([<>=!~]+)?\\s*(.*)?$", line)
+            if match:
+                whitespace = match.group(1)
+                dep_name = match.group(2)#pylint:disable=unused-variable
+                dep_operator = match.group(3) or None
+                dep_version = match.group(4) or None#pylint:disable=unused-variable
+                new_line=whitespace+name
+                if dep_operator is None:
+                    dep_operator=">="
+                new_line=new_line+dep_operator+new_version
+                new_lines.append(new_line)
+            else:
+                new_lines.append(line)
+        GeneralUtilities.write_lines_to_file(setupcfg_file,new_lines)
+
+    def __set_dependency_version_in_requirementstxt(self,name:str,new_version:str)->None:
+        self.__set_dependency_version_in_requirements(name,new_version,os.path.join(self.get_codeunit_folder(),"requirements.txt")) 
+
+    def __set_dependency_version_in_otherrequirementstxt(self,name:str,new_version:str)->None:
+        rfile=os.path.join(self.get_codeunit_folder(),"Other","requirements.txt")
+        if os.path.isfile(rfile):
+            self.__set_dependency_version_in_requirements(name,new_version,rfile) 
+
+    def __set_dependency_version_in_requirements(self,name:str,new_version:str,requirementsfile:str)->None:
+        lines=GeneralUtilities.read_lines_from_file(requirementsfile)
+        new_lines:list[str]=[]
+        for line in lines:
+            match = re.match("^("+re.escape(name)+")\\s*([<>=!~]+)?\\s*(.*)?$", line)
+            if match:
+                dep_name = match.group(1)#pylint:disable=unused-variable
+                dep_operator = match.group(2) or None
+                dep_version = match.group(3) or None#pylint:disable=unused-variable
+                new_line=name
+                if dep_operator is None:
+                    dep_operator=">="
+                new_line=new_line+dep_operator+new_version
+                new_lines.append(new_line)
+            else:
+                new_lines.append(line)
+        GeneralUtilities.write_lines_to_file(requirementsfile,new_lines)
+    
+class TFCPS_CodeUnitSpecific_Python_CLI:
+
+    @staticmethod
+    def parse(file:str)->TFCPS_CodeUnitSpecific_Python_Functions:
+        parser=TFCPS_CodeUnitSpecific_Base_CLI.get_base_parser()
+        #add custom parameter if desired
+        args=parser.parse_args()
+        result:TFCPS_CodeUnitSpecific_Python_Functions=TFCPS_CodeUnitSpecific_Python_Functions(file,LogLevel(int(args.verbosity)),args.targetenvironmenttype,not args.nocache,args.ispremerge)
+        return result