ScriptCollection 4.0.11__py3-none-any.whl → 4.0.13__py3-none-any.whl

ScriptCollection/TFCPS/Flutter/TFCPS_CodeUnitSpecific_Flutter.py

@@ -0,0 +1,43 @@
+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):
+        super().__init__(current_file, verbosity,targetenvironmenttype,use_cache)
+
+
+    @GeneralUtilities.check_arguments
+    def build(self) -> None:
+        pass#TODO
+
+    @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 update_dependencies(self) -> None:
+        pass#TODO
+    
+    @GeneralUtilities.check_arguments
+    def run_testcases(self) -> None:
+        pass#TODO
+
+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)
+        return result

ScriptCollection/TFCPS/NodeJS/TFCPS_CodeUnitSpecific_NodeJS.py

@@ -0,0 +1,123 @@
+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):
+        super().__init__(current_file, verbosity,targetenvironmenttype,use_cache)
+
+
+    @GeneralUtilities.check_arguments
+    def build(self) -> None:
+        self._protected_sc.run_with_epew("npm", "run build", self.get_codeunit_folder())
+        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())
+
+    @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 update_dependencies(self) -> None:
+        pass#TODO
+    
+    @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())
+
+        # 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())
+        self._protected_sc.format_xml_file(self.get_codeunit_folder()+"/"+relative_path_to_bom_file)
+
+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)
+        return result

ScriptCollection/TFCPS/Python/TFCPS_CodeUnitSpecific_Python.py

@@ -0,0 +1,114 @@
+import os
+from ...GeneralUtilities import GeneralUtilities
+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):
+        super().__init__(current_file, verbosity,targetenvironmenttype,use_cache)
+ 
+
+    @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()
+        #TODO check for updateable dependencies (in a unified way)
+
+    @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])
+        self.tfcps_Tools_General.ensure_cyclonedxcli_is_available(repository_folder,not self.use_cache())
+        cyclonedx_exe ="cyclonedx-cli"# cyclonedx_exe = os.path.join(repository_folder, "Other/Resources/CycloneDXCLI/cyclonedx-cli")
+        #if GeneralUtilities.current_system_is_windows():
+        #    cyclonedx_exe = cyclonedx_exe+".exe"
+        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 update_dependencies(self) -> None:
+        pass
+    
+    @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())
+        
+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)
+        return result